@sapui5/sap.fe.core 1.108.2 → 1.110.0

package/src/sap/fe/core/converters/controls/Common/Table.ts

@@ -9,11 +9,11 @@ import type {
 	TypeDefinition
 } from "@sap-ux/vocabularies-types";
 import type { FilterFunctions } from "@sap-ux/vocabularies-types/vocabularies/Capabilities";
-import { EntitySetAnnotations_Capabilities } from "@sap-ux/vocabularies-types/vocabularies/Capabilities_Edm";
+import type { EntitySetAnnotations_Capabilities } from "@sap-ux/vocabularies-types/vocabularies/Capabilities_Edm";
 import type { SemanticKey } from "@sap-ux/vocabularies-types/vocabularies/Common";
 import { CommonAnnotationTerms } from "@sap-ux/vocabularies-types/vocabularies/Common";
-import { EntitySetAnnotations_Common } from "@sap-ux/vocabularies-types/vocabularies/Common_Edm";
-import { EntitySetAnnotations_Session } from "@sap-ux/vocabularies-types/vocabularies/Session_Edm";
+import type { EntitySetAnnotations_Common } from "@sap-ux/vocabularies-types/vocabularies/Common_Edm";
+import type { EntitySetAnnotations_Session } from "@sap-ux/vocabularies-types/vocabularies/Session_Edm";
 import type {
 	CriticalityType,
 	DataField,
@@ -31,21 +31,28 @@ import type {
 	SelectOptionType
 } from "@sap-ux/vocabularies-types/vocabularies/UI";
 import { UIAnnotationTypes } from "@sap-ux/vocabularies-types/vocabularies/UI";
-import type { ComplexPropertyInfo } from "sap/fe/core/converters/annotations/DataField";
 import {
 	collectRelatedProperties,
 	collectRelatedPropertiesRecursively,
+	ComplexPropertyInfo,
 	getDataFieldDataType,
 	getSemanticObjectPath,
-	isDataFieldAlwaysHidden,
+	getTargetValueOnDataPoint,
 	isDataFieldForActionAbstract,
-	isDataFieldTypes
+	isDataFieldTypes,
+	isDataPointFromDataFieldDefault
 } from "sap/fe/core/converters/annotations/DataField";
-import type { AnnotationAction, BaseAction, CombinedAction, CustomAction } from "sap/fe/core/converters/controls/Common/Action";
+import type {
+	AnnotationAction,
+	BaseAction,
+	CombinedAction,
+	CustomAction,
+	OverrideTypeAction
+} from "sap/fe/core/converters/controls/Common/Action";
 import { getActionsFromManifest, isActionNavigable, removeDuplicateActions } from "sap/fe/core/converters/controls/Common/Action";
 import { Entity, UI } from "sap/fe/core/converters/helpers/BindingHelper";
 import type { ConfigurableObject, CustomElement } from "sap/fe/core/converters/helpers/ConfigurableObject";
-import { insertCustomElements, Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
+import { insertCustomElements, OverrideType, Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
 import { IssueCategory, IssueCategoryType, IssueSeverity, IssueType } from "sap/fe/core/converters/helpers/IssueManager";
 import { KeyHelper } from "sap/fe/core/converters/helpers/Key";
 import tableFormatters from "sap/fe/core/formatters/TableFormatter";
@@ -66,9 +73,9 @@ import {
 	resolveBindingString
 } from "sap/fe/core/helpers/BindingToolkit";
 import ModelHelper from "sap/fe/core/helpers/ModelHelper";
-import { replaceSpecialChars } from "sap/fe/core/helpers/StableIdHelper";
+import { generate, replaceSpecialChars } from "sap/fe/core/helpers/StableIdHelper";
+import type { DataModelObjectPath } from "sap/fe/core/templating/DataModelPathHelper";
 import {
-	DataModelObjectPath,
 	enhanceDataModelPath,
 	getTargetObjectPath,
 	isPathDeletable,
@@ -82,11 +89,12 @@ import {
 	getAssociatedCurrencyProperty,
 	getAssociatedTimezoneProperty,
 	getAssociatedUnitProperty,
-	getTargetValueOnDataPoint,
 	isNavigationProperty,
 	isPathExpression,
 	isProperty
 } from "sap/fe/core/templating/PropertyHelper";
+import { isCollectionField } from "sap/fe/core/templating/UIFormatters";
+import { mDefaultTypeForEdmType } from "sap/fe/macros/DelegateUtil";
 import ActionHelper from "sap/fe/macros/internal/helpers/ActionHelper";
 import type ConverterContext from "../../ConverterContext";
 import { AggregationHelper } from "../../helpers/Aggregation";
@@ -160,6 +168,7 @@ export type TableAnnotationConfiguration = {
 	sortConditions?: string;
 	groupConditions?: string;
 	aggregateConditions?: string;
+	initialExpansionLevel?: number;
 
 	/** Create new entries */
 	create: CreateBehavior | CreateBehaviorExternal;
@@ -230,9 +239,10 @@ export type TableControlConfiguration = {
 	enableAutoColumnWidth: boolean;
 	dataStateIndicatorFilter: string | undefined;
 	isCompactType?: boolean;
+	hierarchyQualifier?: string;
 };
 
-export type TableType = "GridTable" | "ResponsiveTable" | "AnalyticalTable";
+export type TableType = "GridTable" | "ResponsiveTable" | "AnalyticalTable" | "TreeTable";
 export type GridTableRowCountMode = "Auto" | "Fixed";
 
 enum ColumnType {
@@ -286,6 +296,47 @@ export type AnnotationTableColumnForOverride = BaseTableColumn & {
 	formatOptions?: FormatOptionsType;
 };
 
+export type configTypeConstraints = Partial<{
+	scale: number;
+	precision: number;
+	maxLength: number;
+	nullable: boolean;
+	minimum: string;
+	maximum: string;
+	isDigitSequence: boolean;
+}>;
+
+export type configTypeformatOptions = Partial<{
+	parseAsString: boolean;
+	emptyString: string;
+	parseKeepsEmptyString: boolean;
+}>;
+
+export type configType = {
+	type?: string;
+	constraints: configTypeConstraints;
+	formatOptions: configTypeformatOptions;
+	typeInstance?: InstanceType<any>;
+	baseType?: string;
+	className?: keyof typeof mDefaultTypeForEdmType;
+};
+
+export type exportSettings = Partial<{
+	template: string;
+	label: string;
+	wrap: boolean;
+	type: string;
+	inputFormat: string;
+	format: string;
+	scale: number;
+	delimiter: boolean;
+	unit: string;
+	unitProperty: string;
+	timezone: string;
+	timezoneProperty: string;
+	utc: boolean;
+}>;
+
 // Properties for Annotation Columns
 export type AnnotationTableColumn = AnnotationTableColumnForOverride & {
 	name: string;
@@ -299,7 +350,7 @@ export type AnnotationTableColumn = AnnotationTableColumnForOverride & {
 	FieldGroupHiddenExpressions?: CompiledBindingToolkitExpression;
 	showDataFieldsLabel?: boolean;
 	isKey?: boolean;
-	isGroupable: boolean;
+	isGroupable?: boolean;
 	unit?: string;
 	unitText?: string;
 	timezoneText?: string;
@@ -307,34 +358,18 @@ export type AnnotationTableColumn = AnnotationTableColumnForOverride & {
 	semanticObjectPath?: string;
 	sortable: boolean;
 	exportSettings?: exportSettings | null;
-	isDataPointFakeTargetProperty?: boolean;
 	textArrangement?: {
 		textProperty: string;
 		mode: DisplayMode;
 	};
 	additionalPropertyInfos?: string[];
 	visualSettings?: VisualSettings;
-	typeConfig?: object;
+	typeConfig?: configType;
 	isPartOfLineItem?: boolean; // temporary indicator to only allow filtering on navigation properties when they're part of a line item
 	additionalLabels?: string[];
+	exportDataPointTargetValue?: string;
 };
 
-export type exportSettings = Partial<{
-	template: string;
-	label: string;
-	wrap: boolean;
-	type: string;
-	inputFormat: string;
-	format: string;
-	scale: number;
-	delimiter: boolean;
-	unit: string;
-	unitProperty: string;
-	timezone: string;
-	timezoneProperty: string;
-	utc: boolean;
-}>;
-
 export type VisualSettings = {
 	widthCalculation?: WidthCalculation;
 };
@@ -375,6 +410,8 @@ export type TableVisualization = {
 	headerInfoTitle: string;
 	semanticKeys: string[];
 	headerInfoTypeName: PropertyAnnotationValue<String> | undefined;
+	enable$select: boolean;
+	enable$$getKeepAliveContext: boolean;
 };
 
 type SorterType = {
@@ -408,19 +445,20 @@ export function getTableActions(
 		true,
 		aHiddenActions
 	);
-	const actions = insertCustomElements(aAnnotationActions, manifestActions.actions, {
-		isNavigable: "overwrite",
-		enableOnSelect: "overwrite",
-		enableAutoScroll: "overwrite",
-		enabled: "overwrite",
-		visible: "overwrite",
-		defaultValuesExtensionFunction: "overwrite",
-		command: "overwrite"
-	});
+	const actionOverwriteConfig: OverrideTypeAction = {
+		isNavigable: OverrideType.overwrite,
+		enableOnSelect: OverrideType.overwrite,
+		enableAutoScroll: OverrideType.overwrite,
+		enabled: OverrideType.overwrite,
+		visible: OverrideType.overwrite,
+		defaultValuesExtensionFunction: OverrideType.overwrite,
+		command: OverrideType.overwrite
+	};
+	const actions = insertCustomElements(aAnnotationActions, manifestActions.actions, actionOverwriteConfig);
 
 	return {
-		"actions": actions,
-		"commandActions": manifestActions.commandActions
+		actions,
+		commandActions: manifestActions.commandActions
 	};
 }
 
@@ -450,13 +488,13 @@ export function getTableColumns(
 	);
 
 	return insertCustomElements(annotationColumns as TableColumn[], manifestColumns as Record<string, CustomElement<TableColumn>>, {
-		width: "overwrite",
-		importance: "overwrite",
-		horizontalAlign: "overwrite",
-		availability: "overwrite",
-		isNavigable: "overwrite",
-		settings: "overwrite",
-		formatOptions: "overwrite"
+		width: OverrideType.overwrite,
+		importance: OverrideType.overwrite,
+		horizontalAlign: OverrideType.overwrite,
+		availability: OverrideType.overwrite,
+		isNavigable: OverrideType.overwrite,
+		settings: OverrideType.overwrite,
+		formatOptions: OverrideType.overwrite
 	});
 }
 
@@ -521,11 +559,7 @@ export const getAggregateDefinitionsFromEntityType = function (
 			const aRawContextDefiningProperties = mRawDefinitions[oTableColumn.relativePath];
 
 			// Ignore aggregates corresponding to currencies or units of measure and dummy created property for datapoint target Value
-			if (
-				aRawContextDefiningProperties &&
-				!mCurrencyOrUnitProperties.has(oTableColumn.name) &&
-				!oTableColumn.isDataPointFakeTargetProperty
-			) {
+			if (aRawContextDefiningProperties && !mCurrencyOrUnitProperties.has(oTableColumn.name)) {
 				mResult[oTableColumn.name] = {
 					defaultAggregate: {},
 					relativePath: oTableColumn.relativePath
@@ -556,7 +590,7 @@ export const getAggregateDefinitionsFromEntityType = function (
  * @param converterContext The converter context
  * @param presentationVariantAnnotation The presentationVariant annotation (if any)
  */
-function updateTableVisualizationForAnalytics(
+export function updateTableVisualizationForType(
 	tableVisualization: TableVisualization,
 	entityType: EntityType,
 	converterContext: ConverterContext,
@@ -568,6 +602,8 @@ function updateTableVisualizationForAnalytics(
 
 		if (aggregatesDefinitions) {
 			tableVisualization.enableAnalytics = true;
+			tableVisualization.enable$select = false;
+			tableVisualization.enable$$getKeepAliveContext = false;
 			tableVisualization.aggregates = aggregatesDefinitions;
 
 			const allowedTransformations = aggregationHelper.getAllowedTransformations();
@@ -592,6 +628,8 @@ function updateTableVisualizationForAnalytics(
 			tableVisualization.columns,
 			tableVisualization.control.type
 		);
+	} else if (tableVisualization.control.type === "TreeTable") {
+		tableVisualization.enable$$getKeepAliveContext = false;
 	}
 }
 
@@ -730,11 +768,13 @@ export function createTableVisualization(
 		operationAvailableProperties: getOperationAvailableProperties(operationAvailableMap, converterContext),
 		headerInfoTitle: semanticKeysAndHeaderInfoTitle.headerInfoTitlePath,
 		semanticKeys: semanticKeysAndHeaderInfoTitle.semanticKeyColumns,
-		headerInfoTypeName: semanticKeysAndHeaderInfoTitle.headerInfoTypeName
+		headerInfoTypeName: semanticKeysAndHeaderInfoTitle.headerInfoTypeName,
+		enable$select: true,
+		enable$$getKeepAliveContext: true
 	};
 
 	updateLinkedProperties(converterContext.getAnnotationEntityType(lineItemAnnotation), columns);
-	updateTableVisualizationForAnalytics(
+	updateTableVisualizationForType(
 		oVisualization,
 		converterContext.getAnnotationEntityType(lineItemAnnotation),
 		converterContext,
@@ -744,14 +784,14 @@ export function createTableVisualization(
 	return oVisualization;
 }
 
-export function createDefaultTableVisualization(converterContext: ConverterContext): TableVisualization {
+export function createDefaultTableVisualization(converterContext: ConverterContext, isBlankTable?: boolean): TableVisualization {
 	const tableManifestConfig = getTableManifestConfiguration(undefined, "", converterContext, false);
 	const columns = getColumnsFromEntityType({}, converterContext.getEntityType(), [], [], converterContext, tableManifestConfig.type, []);
 	const operationAvailableMap = getOperationAvailableMap(undefined, converterContext);
 	const semanticKeysAndHeaderInfoTitle = getSemanticKeysAndTitleInfo(converterContext);
 	const oVisualization: TableVisualization = {
 		type: VisualizationType.Table,
-		annotation: getTableAnnotationConfiguration(undefined, "", converterContext, tableManifestConfig, columns),
+		annotation: getTableAnnotationConfiguration(undefined, "", converterContext, tableManifestConfig, isBlankTable ? [] : columns),
 		control: tableManifestConfig,
 		actions: [],
 		columns: columns,
@@ -759,11 +799,13 @@ export function createDefaultTableVisualization(converterContext: ConverterConte
 		operationAvailableProperties: getOperationAvailableProperties(operationAvailableMap, converterContext),
 		headerInfoTitle: semanticKeysAndHeaderInfoTitle.headerInfoTitlePath,
 		semanticKeys: semanticKeysAndHeaderInfoTitle.semanticKeyColumns,
-		headerInfoTypeName: semanticKeysAndHeaderInfoTitle.headerInfoTypeName
+		headerInfoTypeName: semanticKeysAndHeaderInfoTitle.headerInfoTypeName,
+		enable$select: true,
+		enable$$getKeepAliveContext: true
 	};
 
 	updateLinkedProperties(converterContext.getEntityType(), columns);
-	updateTableVisualizationForAnalytics(oVisualization, converterContext.getEntityType(), converterContext);
+	updateTableVisualizationForType(oVisualization, converterContext.getEntityType(), converterContext);
 
 	return oVisualization;
 }
@@ -923,14 +965,54 @@ function getBindingExpFromContext(
 }
 
 /**
- * Loop through the DataFieldForAction and DataFieldForIntentBasedNavigation of a line item and check
- * if at least one of them is always visible in the table toolbar (and requires a context).
+ * Loop through the manifest actions and check the following:
+ *
+ * If the data field is also referenced as a custom action.
+ * If the underlying manifest action is either a bound action or has the 'RequiresContext' property set to true.
+ *
+ * If so, the 'requiresSelection' property is forced to 'true' in the manifest.
+ *
+ * @param dataFieldId Id of the DataField evaluated
+ * @param dataField DataField evaluated
+ * @param manifestActions The actions defined in the manifest
+ * @returns `true` if the DataField is found among the manifest actions
+ */
+function updateManifestActionAndTagIt(
+	dataFieldId: string,
+	dataField: DataFieldForAction | DataFieldForIntentBasedNavigation,
+	manifestActions: Record<string, CustomAction>
+): boolean {
+	return Object.keys(manifestActions).some((actionKey) => {
+		if (actionKey === dataFieldId) {
+			if (
+				(dataField as DataFieldForAction)?.ActionTarget?.isBound ||
+				(dataField as DataFieldForIntentBasedNavigation)?.RequiresContext
+			) {
+				manifestActions[dataFieldId].requiresSelection = true;
+			}
+			return true;
+		}
+		return false;
+	});
+}
+
+/**
+ * Loop through the DataFieldForAction and DataFieldForIntentBasedNavigation of a line item and
+ * check the following:
+ * If at least one of them is always visible in the table toolbar and requires a context
+ * If an action is also defined in the manifest, it is set aside and will be considered
+ * when going through the manifest.
  *
  * @param lineItemAnnotation Collection of data fields for representation in a table or list
+ * @param manifestActions The actions defined in the manifest
  * @param currentEntityType Current Entity Type
  * @returns `true` if there is at least 1 action that meets the criteria
  */
-function hasBoundActionsAlwaysVisibleInToolBar(lineItemAnnotation: LineItem, currentEntityType: EntityType): boolean {
+function hasBoundActionsAlwaysVisibleInToolBar(
+	lineItemAnnotation: LineItem,
+	manifestActions: Record<string, CustomAction>,
+	currentEntityType: EntityType
+): boolean {
 	return lineItemAnnotation.some((dataField) => {
 		if (
 			(dataField.$Type === UIAnnotationTypes.DataFieldForAction ||
@@ -939,9 +1021,24 @@ function hasBoundActionsAlwaysVisibleInToolBar(lineItemAnnotation: LineItem, cur
 			(dataField.annotations?.UI?.Hidden?.valueOf() === false || dataField.annotations?.UI?.Hidden?.valueOf() === undefined)
 		) {
 			if (dataField.$Type === UIAnnotationTypes.DataFieldForAction) {
+				const manifestActionId = generate(["DataFieldForAction", dataField.Action as string]);
+				// if the DataFieldForActon from annotation also exists in the manifest, its visibility will be evaluated later on
+				if (updateManifestActionAndTagIt(manifestActionId, dataField, manifestActions)) {
+					return false;
+				}
 				// Check if the lineItem context is the same as that of the action:
 				return dataField?.ActionTarget?.isBound && currentEntityType === dataField?.ActionTarget.sourceEntityType;
 			} else if (dataField.$Type === UIAnnotationTypes.DataFieldForIntentBasedNavigation) {
+				// if the DataFieldForIntentBasedNavigation from annotation also exists in the manifest, its visibility will be evaluated later on
+				if (
+					updateManifestActionAndTagIt(
+						`DataFieldForIntentBasedNavigation::${dataField.SemanticObject}::${dataField.Action}`,
+						dataField,
+						manifestActions
+					)
+				) {
+					return false;
+				}
 				return dataField.RequiresContext;
 			}
 		}
@@ -1057,7 +1154,7 @@ export function getSelectionMode(
 	}
 
 	if (
-		hasBoundActionsAlwaysVisibleInToolBar(lineItemAnnotation, converterContext.getEntityType()) ||
+		hasBoundActionsAlwaysVisibleInToolBar(lineItemAnnotation, manifestActions.actions, converterContext.getEntityType()) ||
 		hasCustomActionsAlwaysVisibleInToolBar(manifestActions.actions)
 	) {
 		return selectionMode;
@@ -1327,10 +1424,10 @@ function _getCreationBehaviour(
 
 const _getRowConfigurationProperty = function (
 	lineItemAnnotation: LineItem | undefined,
-	visualizationPath: string,
 	converterContext: ConverterContext,
 	navigationSettings: NavigationSettingsConfiguration,
-	targetPath: string
+	targetPath: string,
+	tableType: TableType
 ) {
 	let pressProperty, navigationTarget;
 	let criticalityProperty: BindingToolkitExpression<MessageType> = constant(MessageType.None);
@@ -1356,6 +1453,7 @@ const _getRowConfigurationProperty = function (
 					(ModelHelper.getDraftRoot(targetEntitySet) || ModelHelper.getDraftNode(targetEntitySet)
 						? "!${$parameters>bindingContext}.getProperty('IsActiveEntity')"
 						: "undefined") +
+					(tableType === "AnalyticalTable" || tableType === "TreeTable" ? ", bRecreateContext: true" : "") +
 					"})"; //Need to access to DraftRoot and DraftNode !!!!!!!
 			} else {
 				criticalityProperty = getHighlightRowBinding(lineItemAnnotation.annotations?.UI?.Criticality, false, targetEntityType);
@@ -1464,6 +1562,10 @@ export const getColumnsFromEntityType = function (
 				} else if (relatedPropertiesInfo.exportTimezoneString) {
 					columnInfo.exportSettings.timezone = relatedPropertiesInfo.exportTimezoneString;
 				}
+				if (relatedPropertiesInfo.exportDataPointTargetValue) {
+					columnInfo.exportDataPointTargetValue = relatedPropertiesInfo.exportDataPointTargetValue;
+					columnInfo.exportSettings.type = "String";
+				}
 
 				// Collect information of related columns to be created.
 				relatedPropertyNames.forEach((name) => {
@@ -1546,89 +1648,81 @@ const getColumnDefinitionFromProperty = function (
 	const isHidden = property.annotations?.UI?.Hidden?.valueOf() === true;
 	const groupPath: string | undefined = property.name ? _sliceAtSlash(property.name, true, false) : undefined;
 	const isGroup: boolean = groupPath != property.name;
-	const isDataPointFakeProperty: boolean = name.indexOf("@com.sap.vocabularies.UI.v1.DataPoint") > -1;
 	const exportType: string = _getExportDataType(property.type);
 	const sDateInputFormat: string | undefined = property.type === "Edm.Date" ? "YYYY-MM-DD" : undefined;
 	const dataType: string | undefined = getDataFieldDataType(property);
-	const propertyTypeConfig = !isDataPointFakeProperty ? getTypeConfig(property, dataType) : undefined;
+	const propertyTypeConfig = getTypeConfig(property, dataType);
 	const semanticKeys: SemanticKey = converterContext.getAnnotationsByTerm("Common", CommonAnnotationTerms.SemanticKey, [
 		converterContext.getEntityType()
 	])[0];
 	const isAPropertyFromTextOnlyAnnotation =
 		textOnlyColumnsFromTextAnnotation && textOnlyColumnsFromTextAnnotation.indexOf(relativePath) >= 0;
-	const sortable =
-		(!isHidden || isAPropertyFromTextOnlyAnnotation) && nonSortableColumns.indexOf(relativePath) === -1 && !isDataPointFakeProperty;
-	const oTypeConfig = !isDataPointFakeProperty
-		? {
-				className: property.type || dataType,
-				oFormatOptions: propertyTypeConfig.formatOptions,
-				oConstraints: propertyTypeConfig.constraints
-		  }
-		: undefined;
-	let exportSettings: exportSettings | null = isDataPointFakeProperty
-		? {
-				template: getTargetValueOnDataPoint(property)
-		  }
-		: null;
-
-	if (!isDataPointFakeProperty && _isExportableColumn(property)) {
-		const oUnitProperty = getAssociatedCurrencyProperty(property) || getAssociatedUnitProperty(property);
-		const oTimezoneProperty = getAssociatedTimezoneProperty(property);
-		const sUnitText = property?.annotations?.Measures?.ISOCurrency || property?.annotations?.Measures?.Unit;
-		const sTimezoneText = property?.annotations?.Common?.Timezone;
+	const sortable = (!isHidden || isAPropertyFromTextOnlyAnnotation) && nonSortableColumns.indexOf(relativePath) === -1;
+	const typeConfig = {
+		className: property.type || dataType,
+		formatOptions: propertyTypeConfig.formatOptions,
+		constraints: propertyTypeConfig.constraints
+	};
+	let exportSettings: exportSettings | null = null;
+	if (_isExportableColumn(property)) {
+		const unitProperty = getAssociatedCurrencyProperty(property) || getAssociatedUnitProperty(property);
+		const timezoneProperty = getAssociatedTimezoneProperty(property);
+		const unitText = property.annotations?.Measures?.ISOCurrency || property.annotations?.Measures?.Unit;
+		const timezoneText = property.annotations?.Common?.Timezone;
+
 		exportSettings = {
 			type: exportType,
 			inputFormat: sDateInputFormat,
 			scale: property.scale,
 			delimiter: property.type === "Edm.Int64"
 		};
-		if (oUnitProperty) {
-			exportSettings.unitProperty = oUnitProperty.name;
+
+		if (unitProperty) {
+			exportSettings.unitProperty = unitProperty.name;
 			exportSettings.type = "Currency"; // Force to a currency because there's a unitProperty (otherwise the value isn't properly formatted when exported)
-		} else if (sUnitText) {
-			exportSettings.unit = `${sUnitText}`;
+		} else if (unitText) {
+			exportSettings.unit = `${unitText}`;
 		}
-		if (oTimezoneProperty) {
-			exportSettings.timezoneProperty = oTimezoneProperty.name;
+		if (timezoneProperty) {
+			exportSettings.timezoneProperty = timezoneProperty.name;
 			exportSettings.utc = false;
-		} else if (sTimezoneText) {
-			exportSettings.timezone = sTimezoneText.toString();
+		} else if (timezoneText) {
+			exportSettings.timezone = timezoneText.toString();
 		}
 	}
+
 	const collectedNavigationPropertyLabels: string[] | undefined = _getCollectedNavigationPropertyLabels(relativePath, converterContext);
 
-	const oColumn: any = {
+	const column: AnnotationTableColumn = {
 		key: key,
 		type: ColumnType.Annotation,
 		label: getLabel(property, isGroup),
-		groupLabel: isGroup ? getLabel(property) : null,
-		group: isGroup ? groupPath : null,
+		groupLabel: isGroup ? getLabel(property) : undefined,
+		group: isGroup ? groupPath : undefined,
 		annotationPath: fullPropertyPath,
 		semanticObjectPath: semanticObjectAnnotationPath,
-		// A fake property was created for the TargetValue used on DataPoints, this property should be hidden and non sortable
-		availability:
-			!availableForAdaptation || isHidden || isDataPointFakeProperty ? AvailabilityType.Hidden : AvailabilityType.Adaptation,
+		availability: !availableForAdaptation || isHidden ? AvailabilityType.Hidden : AvailabilityType.Adaptation,
 		name: name,
-		relativePath: isDataPointFakeProperty
-			? (property as any).annotations?.UI?.DataFieldDefault?.Target?.$target?.Value?.path || (property as any).Value.path
-			: relativePath,
+		relativePath: relativePath,
 		sortable: sortable,
-		isGroupable: aggregationHelper.isAnalyticsSupported() ? aggregationHelper.isPropertyGroupable(property) : sortable,
+		isGroupable: aggregationHelper.isAnalyticsSupported() ? !!aggregationHelper.isPropertyGroupable(property) : sortable,
 		isKey: property.isKey,
-		isDataPointFakeTargetProperty: isDataPointFakeProperty,
 		exportSettings: exportSettings,
 		caseSensitive: isFilteringCaseSensitive(converterContext),
-		typeConfig: oTypeConfig,
-		visualSettings: isDataPointFakeProperty ? { widthCalculation: null } : undefined,
+		typeConfig: typeConfig as configType,
 		importance: getImportance((property as any).annotations?.UI?.DataFieldDefault, semanticKeys),
 		additionalLabels: collectedNavigationPropertyLabels
 	};
 	const sTooltip = _getTooltip(property);
 	if (sTooltip) {
-		oColumn.tooltip = sTooltip;
+		column.tooltip = sTooltip;
 	}
-
-	return oColumn as AnnotationTableColumn;
+	const targetValuefromDP = getTargetValueOnDataPoint(property);
+	if (isDataPointFromDataFieldDefault(property) && typeof targetValuefromDP === "string" && column.exportSettings) {
+		column.exportDataPointTargetValue = targetValuefromDP;
+		column.exportSettings.template = "{0}/" + targetValuefromDP;
+	}
+	return column;
 };
 
 /**
@@ -1641,15 +1735,20 @@ const getColumnDefinitionFromProperty = function (
 
 function _isExportableColumn(source: DataFieldAbstractTypes | Property): boolean {
 	let propertyType, property;
-	const dataFieldDefaultPropertyType = (source as Property).annotations?.UI?.DataFieldDefault?.$Type;
-	if (isProperty(source && dataFieldDefaultPropertyType)) {
-		propertyType = dataFieldDefaultPropertyType;
+	const dataFieldDefaultProperty = (source as Property).annotations.UI?.DataFieldDefault;
+	if (isProperty(source) && dataFieldDefaultProperty?.$Type) {
+		if (isReferencePropertyStaticallyHidden(dataFieldDefaultProperty) === true) {
+			return false;
+		}
+		propertyType = dataFieldDefaultProperty?.$Type;
+	} else if (isReferencePropertyStaticallyHidden(source as DataFieldAbstractTypes) === true) {
+		return false;
 	} else {
 		property = source as DataFieldAbstractTypes;
 		propertyType = property.$Type;
-		if (propertyType === UIAnnotationTypes.DataFieldForAnnotation && (property as DataFieldForAnnotation).Target.$target?.$Type) {
+		if (propertyType === UIAnnotationTypes.DataFieldForAnnotation && (property as DataFieldForAnnotation).Target?.$target?.$Type) {
 			//For Chart
-			propertyType = (property as DataFieldForAnnotation).Target.$target.$Type;
+			propertyType = (property as DataFieldForAnnotation).Target?.$target?.$Type;
 			return UIAnnotationTypes.ChartDefinitionType.indexOf(propertyType) === -1;
 		} else if (
 			(property as DataField).Value?.$target?.annotations?.Core?.MediaType?.term === "Org.OData.Core.V1.MediaType" &&
@@ -1755,7 +1854,6 @@ export const _getVisibleExpression = function (
  *
  * @param dataFieldGroup DataField defined in the annotations
  * @param fieldFormatOptions FormatOptions optional.
- * @param fieldFormatOptions.isAnalytics This flag is used to check if the analytic table has GroupHeader expanded.
  * @returns Compile binding of field group expressions.
  * @private
  */
@@ -1763,17 +1861,21 @@ const _getFieldGroupHiddenExpressions = function (
 	dataFieldGroup: DataFieldAbstractTypes,
 	fieldFormatOptions: any
 ): CompiledBindingToolkitExpression | undefined {
-	const aFieldGroupHiddenExpressions: BindingToolkitExpression<any>[] = [];
+	const fieldGroupHiddenExpressions: BindingToolkitExpression<any>[] = [];
 	if (
 		dataFieldGroup.$Type === UIAnnotationTypes.DataFieldForAnnotation &&
 		dataFieldGroup.Target?.$target?.$Type === UIAnnotationTypes.FieldGroupType
 	) {
-		dataFieldGroup.Target.$target.Data?.forEach((innerDataField: DataFieldAbstractTypes | DataPointTypeTypes) => {
-			aFieldGroupHiddenExpressions.push(
-				_getVisibleExpression({ targetObject: innerDataField } as DataModelObjectPath, fieldFormatOptions)
-			);
-		});
-		return compileExpression(ifElse(or(...aFieldGroupHiddenExpressions), constant(true), constant(false)));
+		if (dataFieldGroup?.annotations?.UI?.Hidden) {
+			return compileExpression(not(equal(getExpressionFromAnnotation(dataFieldGroup.annotations.UI.Hidden), true)));
+		} else {
+			dataFieldGroup.Target.$target.Data?.forEach((innerDataField: DataFieldAbstractTypes | DataPointTypeTypes) => {
+				fieldGroupHiddenExpressions.push(
+					_getVisibleExpression({ targetObject: innerDataField } as DataModelObjectPath, fieldFormatOptions)
+				);
+			});
+			return compileExpression(ifElse(or(...fieldGroupHiddenExpressions), constant(true), constant(false)));
+		}
 	} else {
 		return undefined;
 	}
@@ -2024,6 +2126,22 @@ const _sliceAtSlash = function (path: string, isLastSlash: boolean, isLastPart:
 	return isLastPart ? path.substring(iSlashIndex + 1, path.length) : path.substring(0, iSlashIndex);
 };
 
+/**
+ * Determines if the column contains a multi-value field.
+ *
+ * @param dataField The DataField being processed
+ * @param converterContext The converter context
+ * @returns True if the DataField corresponds to a multi-value field.
+ */
+const _isColumnMultiValued = function (dataField: DataFieldAbstractTypes, converterContext: ConverterContext): boolean {
+	if (isDataFieldTypes(dataField) && isPathExpression(dataField.Value)) {
+		const propertyObjectPath = enhanceDataModelPath(converterContext.getDataModelObjectPath(), dataField.Value.path);
+		return isCollectionField(propertyObjectPath);
+	} else {
+		return false;
+	}
+};
+
 /**
  * Determine whether a column is sortable.
  *
@@ -2297,6 +2415,10 @@ const getColumnsFromAnnotations = function (
 		converterContext.getEntityType()
 	])[0];
 	if (lineItemAnnotation) {
+		const tableConverterContext = converterContext.getConverterContextFor(
+			getTargetObjectPath(converterContext.getDataModelObjectPath())
+		);
+
 		lineItemAnnotation.forEach((lineItem) => {
 			if (!_isValidColumn(lineItem)) {
 				return;
@@ -2307,26 +2429,10 @@ const getColumnsFromAnnotations = function (
 					? getSemanticObjectPath(converterContext, lineItem)
 					: undefined;
 			const relativePath = _getRelativePath(lineItem);
-			let relatedPropertyNames: string[];
+
 			// Determine properties which are consumed by this LineItem.
 			const relatedPropertiesInfo: ComplexPropertyInfo = collectRelatedPropertiesRecursively(lineItem, converterContext, tableType);
-			const relatedProperties: any = relatedPropertiesInfo.properties;
-			if (
-				lineItem.$Type === UIAnnotationTypes.DataFieldForAnnotation &&
-				lineItem.Target?.$target?.$Type === UIAnnotationTypes.FieldGroupType
-			) {
-				relatedPropertyNames = Object.keys(relatedPropertiesInfo.properties).filter((key) => {
-					let isStaticallyHidden;
-					if (relatedProperties[key].annotations?.UI) {
-						isStaticallyHidden = isReferencePropertyStaticallyHidden(relatedProperties[key].annotations?.UI?.DataFieldDefault);
-					} else {
-						isStaticallyHidden = isReferencePropertyStaticallyHidden(relatedProperties[key]);
-					}
-					return !isStaticallyHidden;
-				});
-			} else {
-				relatedPropertyNames = Object.keys(relatedPropertiesInfo.properties);
-			}
+			const relatedPropertyNames: string[] = Object.keys(relatedPropertiesInfo.properties);
 			const additionalPropertyNames: string[] = Object.keys(relatedPropertiesInfo.additionalProperties);
 			const groupPath: string = _sliceAtSlash(relativePath, true, false);
 			const isGroup: boolean = groupPath != relativePath;
@@ -2372,62 +2478,70 @@ const getColumnsFromAnnotations = function (
 			}
 
 			const propertyTypeConfig = dataType && getTypeConfig(lineItem, dataType);
-			const oTypeConfig = propertyTypeConfig
-				? {
-						className: dataType,
-						oFormatOptions: {
-							...formatOptions,
-							...propertyTypeConfig.formatOptions
-						},
-						oConstraints: propertyTypeConfig.constraints
-				  }
-				: undefined;
+			const typeConfig: configType = {
+				className: dataType as keyof typeof mDefaultTypeForEdmType,
+				formatOptions: {
+					...formatOptions,
+					...propertyTypeConfig?.formatOptions
+				},
+				constraints: propertyTypeConfig?.constraints
+			};
 			const visualSettings: VisualSettings = {};
-			if (!dataType || !oTypeConfig) {
+			if (!dataType || !typeConfig) {
 				// for charts
 				visualSettings.widthCalculation = null;
 			}
-
-			const oColumn: any = {
+			const isMultiValue = _isColumnMultiValued(lineItem, tableConverterContext);
+			const sortable = !isMultiValue && _isColumnSortable(lineItem, relativePath, nonSortableColumns);
+			const column: AnnotationTableColumn = {
 				key: KeyHelper.generateKeyFromDataField(lineItem),
 				type: ColumnType.Annotation,
 				label: sLabel,
-				groupLabel: isGroup ? getLabel(lineItem) : null,
-				group: isGroup ? groupPath : null,
+				groupLabel: isGroup ? getLabel(lineItem) : undefined,
+				group: isGroup ? groupPath : undefined,
 				FieldGroupHiddenExpressions: fieldGroupHiddenExpressions,
 				annotationPath: converterContext.getEntitySetBasedAnnotationPath(lineItem.fullyQualifiedName),
 				semanticObjectPath: semanticObjectAnnotationPath,
-				availability: isDataFieldAlwaysHidden(lineItem) ? AvailabilityType.Hidden : AvailabilityType.Default,
+				availability: isReferencePropertyStaticallyHidden(lineItem) ? AvailabilityType.Hidden : AvailabilityType.Default,
 				name: name,
 				showDataFieldsLabel: showDataFieldsLabel,
 				relativePath: relativePath,
-				sortable: _isColumnSortable(lineItem, relativePath, nonSortableColumns),
+				sortable: sortable,
 				propertyInfos: relatedPropertyNames.length ? relatedPropertyNames : undefined,
 				additionalPropertyInfos: additionalPropertyNames.length > 0 ? additionalPropertyNames : undefined,
 				exportSettings: exportSettings,
-				width: lineItem.annotations?.HTML5?.CssDefaults?.width || undefined,
+				width: (lineItem.annotations?.HTML5?.CssDefaults?.width?.valueOf() as string) || undefined,
 				importance: getImportance(lineItem as DataFieldTypes, semanticKeys),
 				isNavigable: true,
 				formatOptions: formatOptions,
 				caseSensitive: isFilteringCaseSensitive(converterContext),
-				typeConfig: oTypeConfig,
+				typeConfig: typeConfig,
 				visualSettings: visualSettings,
 				timezoneText: exportSettings?.timezone,
 				isPartOfLineItem: true
 			};
 			const sTooltip = _getTooltip(lineItem);
 			if (sTooltip) {
-				oColumn.tooltip = sTooltip;
+				column.tooltip = sTooltip;
 			}
 			if (relatedPropertiesInfo.textOnlyPropertiesFromTextAnnotation.length > 0) {
 				textOnlyColumnsFromTextAnnotation.push(...relatedPropertiesInfo.textOnlyPropertiesFromTextAnnotation);
 			}
+			if (relatedPropertiesInfo.exportDataPointTargetValue && column.exportSettings) {
+				column.exportDataPointTargetValue = relatedPropertiesInfo.exportDataPointTargetValue;
+				column.exportSettings.type = "String";
+			}
 
-			annotationColumns.push(oColumn);
+			annotationColumns.push(column);
 
 			// Collect information of related columns to be created.
 			relatedPropertyNames.forEach((relatedPropertyName) => {
 				columnsToBeCreated[relatedPropertyName] = relatedPropertiesInfo.properties[relatedPropertyName];
+
+				// In case of a multi-value, related properties cannot be sorted as we go through a 1-n relation
+				if (isMultiValue) {
+					nonSortableColumns.push(relatedPropertyName);
+				}
 			});
 
 			// Create columns for additional properties identified for ALP use case.
@@ -2767,6 +2881,15 @@ function getSortConditions(
 	return sortConditions;
 }
 
+function getInitialExpansionLevel(presentationVariantAnnotation: PresentationVariantType | undefined): number | undefined {
+	if (!presentationVariantAnnotation) {
+		return undefined;
+	}
+
+	const level = presentationVariantAnnotation.InitialExpansionLevel?.valueOf();
+
+	return typeof level === "number" ? level : undefined;
+}
 /**
  * Converts an array of propertyPath to an array of propertyInfo names.
  *
@@ -2777,11 +2900,12 @@ function getSortConditions(
 
 function convertPropertyPathsToInfoNames(paths: PropertyPath[], columns: TableColumn[]): string[] {
 	const infoNames: string[] = [];
+	let propertyInfo: TableColumn | undefined, annotationColumn: AnnotationTableColumn;
 	paths.forEach((currentPath) => {
-		if (currentPath?.$target?.name) {
-			const propertyInfo = columns.find((column) => {
-				const annotationColumn = column as AnnotationTableColumn;
-				return !annotationColumn.propertyInfos && annotationColumn.relativePath === currentPath?.$target?.name;
+		if (currentPath?.value) {
+			propertyInfo = columns.find((column) => {
+				annotationColumn = column as AnnotationTableColumn;
+				return !annotationColumn.propertyInfos && annotationColumn.relativePath === currentPath?.value;
 			});
 			if (propertyInfo) {
 				infoNames.push(propertyInfo.name);
@@ -2906,7 +3030,7 @@ export function getTableAnnotationConfiguration(
 	const isSearchable = isPathSearchable(converterContext.getDataModelObjectPath());
 	const standardActions = {
 		create: getStandardActionCreate(converterContext, standardActionsContext),
-		"delete": getStandardActionDelete(converterContext, standardActionsContext),
+		delete: getStandardActionDelete(converterContext, standardActionsContext),
 		paste: getStandardActionPaste(converterContext, standardActionsContext, isInsertUpdateTemplated),
 		massEdit: getStandardActionMassEdit(converterContext, standardActionsContext),
 		creationRow: getCreationRow(converterContext, standardActionsContext)
@@ -2919,10 +3043,10 @@ export function getTableAnnotationConfiguration(
 		navigationPath: navigationPropertyPath,
 		row: _getRowConfigurationProperty(
 			lineItemAnnotation,
-			visualizationPath,
 			converterContext,
 			navigationSettings,
-			navigationTargetPath
+			navigationTargetPath,
+			tableManifestConfiguration.type
 		),
 		p13nMode: p13nMode,
 		standardActions: {
@@ -2942,7 +3066,8 @@ export function getTableAnnotationConfiguration(
 		threshold: threshold,
 		sortConditions: getSortConditions(converterContext, presentationVariantAnnotation, columns),
 		title: title,
-		searchable: tableManifestConfiguration.type !== "AnalyticalTable" && !(isConstant(isSearchable) && isSearchable.value === false)
+		searchable: tableManifestConfiguration.type !== "AnalyticalTable" && !(isConstant(isSearchable) && isSearchable.value === false),
+		initialExpansionLevel: getInitialExpansionLevel(presentationVariantAnnotation)
 	};
 }
 
@@ -3070,9 +3195,9 @@ function _getTableType(
 ): TableType {
 	let tableType = tableSettings?.type || "ResponsiveTable";
 	/*  Now, we keep the configuration in the manifest, even if it leads to errors.
-		We only change if we're not on desktop from Analytical to Responsive.
+		We only change if we're not on desktop from Analytical/Tree to Responsive.
 	 */
-	if (tableType === "AnalyticalTable" && !converterContext.getManifestWrapper().isDesktop()) {
+	if ((tableType === "AnalyticalTable" || tableType === "TreeTable") && !converterContext.getManifestWrapper().isDesktop()) {
 		tableType = "ResponsiveTable";
 	}
 	return tableType;
@@ -3224,30 +3349,15 @@ export function getTableManifestConfiguration(
 		useCondensedTableLayout: condensedTableLayout && isCondensedTableLayoutCompliant,
 		isCompactType: _manifestWrapper.isCompactType()
 	};
-	return { ...oConfiguration, ...gridTableRowMode, ...oFilterConfiguration };
-}
 
-export type configTypeConstraints = {
-	scale?: number;
-	precision?: number;
-	maxLength?: number;
-	nullable?: boolean;
-	minimum?: string;
-	maximum?: string;
-	isDigitSequence?: boolean;
-};
+	const tableConfiguration: TableControlConfiguration = { ...oConfiguration, ...gridTableRowMode, ...oFilterConfiguration };
 
-export type configTypeformatOptions = {
-	parseAsString?: boolean;
-	emptyString?: string;
-	parseKeepsEmptyString?: boolean;
-};
+	if (tableType === "TreeTable") {
+		tableConfiguration.hierarchyQualifier = tableSettings.hierarchyQualifier;
+	}
 
-export type configType = {
-	type: string;
-	constraints: configTypeConstraints;
-	formatOptions: configTypeformatOptions;
-};
+	return tableConfiguration;
+}
 
 export function getTypeConfig(oProperty: Property | DataFieldAbstractTypes, dataType: string | undefined): any {
 	let oTargetMapping = EDM_TYPE_MAPPING[(oProperty as Property)?.type] || (dataType ? EDM_TYPE_MAPPING[dataType] : undefined);
@@ -3316,5 +3426,6 @@ export default {
 	splitPath,
 	getSelectionVariantConfiguration,
 	getTableManifestConfiguration,
-	getTypeConfig
+	getTypeConfig,
+	updateTableVisualizationForType
 };