@sapui5/sap.fe.core 1.131.0 → 1.133.0

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

@@ -18,6 +18,7 @@ import type {
 	DataField,
 	DataFieldAbstractTypes,
 	DataFieldForAction,
+	DataFieldForActionGroup,
 	DataFieldForActionTypes,
 	DataFieldForAnnotation,
 	DataFieldForIntentBasedNavigation,
@@ -61,13 +62,16 @@ import {
 	hasFieldGroupTarget,
 	isDataField,
 	isDataFieldForActionAbstract,
+	isDataFieldForActionGroup,
 	isDataFieldForAnnotation,
 	isDataFieldTypes,
 	isDataPointFromDataFieldDefault,
-	isRatingVisualizationFromDataFieldDefault
+	isRatingVisualizationFromDataFieldDefault,
+	visibleExpression
 } from "sap/fe/core/converters/annotations/DataField";
 import type {
 	AnnotationAction,
+	AnnotationActionGroup,
 	BaseAction,
 	CombinedAction,
 	CustomAction,
@@ -76,9 +80,12 @@ import type {
 import {
 	dataFieldIsCopyAction,
 	getActionsFromManifest,
+	getAnnotationMenuActionItems,
 	getCopyAction,
 	getEnabledForAnnotationAction,
-	isActionNavigable,
+	getMatchingManifestAction,
+	getVisibilityEnablementMenuActions,
+	prepareMenuActions,
 	removeDuplicateActions
 } from "sap/fe/core/converters/controls/Common/Action";
 import type { ConfigurableObject, CustomElement } from "sap/fe/core/converters/helpers/ConfigurableObject";
@@ -96,9 +103,11 @@ import {
 	isProperty,
 	isTypeDefinition
 } from "sap/fe/core/helpers/TypeGuards";
+import { criticalityExpressionForIntegrationCards } from "sap/fe/core/templating/CriticalityFormatters";
 import {
 	enhanceDataModelPath,
 	getContextPropertyRestriction,
+	getContextRelativeTargetObjectPath,
 	getHierarchyParentNavigationPropertyPath,
 	getNonUpdatableNavigationProperties,
 	getTargetObjectPath,
@@ -112,9 +121,12 @@ import { getRestrictionsOnProperties, type RestrictionsOnProperties } from "sap/
 import { hasFieldControlNotMandatory, isStaticallyMandatory } from "sap/fe/core/templating/FieldControlHelper";
 import {
 	getAssociatedCurrencyProperty,
+	getAssociatedCurrencyPropertyPath,
 	getAssociatedTextProperty,
+	getAssociatedTextPropertyPath,
 	getAssociatedTimezoneProperty,
 	getAssociatedUnitProperty,
+	getAssociatedUnitPropertyPath,
 	getStaticTimezone,
 	getStaticUnitOrCurrency,
 	isTimezone
@@ -185,12 +197,28 @@ type UploadTableSettings = {
 	maxLength?: int;
 	uploadAction?: StandardAction;
 };
+
+type RowNavigationInfo =
+	| {
+			type: "Outbound";
+			navigationTarget: string;
+			navigationInEditMode?: boolean;
+	  }
+	| {
+			type: "Navigation";
+			targetPath: string;
+			checkEditable: boolean;
+			recreateContext: boolean;
+			routePath: string;
+			navigationInEditMode?: boolean;
+	  };
+
 type RowConfiguration = {
 	action?: string;
-	press?: string;
-	openInNewTabPress?: string;
+	navigationInfo?: RowNavigationInfo;
 	rowHighlighting: CompiledBindingToolkitExpression;
 	rowNavigated: CompiledBindingToolkitExpression;
+	rowCriticalityForInsights?: CompiledBindingToolkitExpression;
 	visible?: CompiledBindingToolkitExpression;
 };
 
@@ -217,6 +245,10 @@ type TableAggregateConditions = Record<string, object>;
 
 type TableP13nMode = "Aggregate" | "Column" | "Filter" | "Group" | "Sort";
 
+export type AnalyticalConfiguration = {
+	aggregationOnLeafLevel?: boolean;
+};
+
 export type TableAnnotationConfiguration = {
 	collection: string;
 	variantManagement: VariantManagementType;
@@ -314,7 +346,7 @@ export type TableControlConfiguration = {
 	inlineCreationRowsHiddenInEditMode?: boolean;
 	massEdit: MassEditTableConfiguration;
 	enableAutoColumnWidth: boolean;
-	dataStateIndicatorFilter: string | undefined;
+	hasDataStateIndicatorFilter: boolean;
 	isCompactType?: boolean;
 	hierarchyQualifier?: string;
 	isHierarchyParentNodeUpdatable?: boolean;
@@ -333,9 +365,10 @@ export type TableControlConfiguration = {
 	exportRequestSize?: number;
 	enableUploadPlugin?: boolean;
 	modeForNoDataMessage?: string;
+	analyticalConfiguration?: AnalyticalConfiguration;
 };
 export type TableType = "GridTable" | "ResponsiveTable" | "AnalyticalTable" | "TreeTable";
-export type TableRowCountMode = "Auto" | "Fixed";
+export type TableRowCountMode = "Auto" | "Fixed" | "Interactive";
 
 enum ColumnType {
 	Default = "Default", // Default Type (Custom Column)
@@ -473,6 +506,7 @@ export type AnnotationTableColumn = AnnotationTableColumnForOverride & {
 	visualSettings?: VisualSettings;
 	typeConfig?: PropertyTypeConfig;
 	isPartOfLineItem?: boolean; // temporary indicator to only allow filtering on navigation properties when they're part of a line item
+	isPartOfCustomColumn?: boolean;
 	additionalLabels?: string[];
 	exportDataPointTargetValue?: string;
 	aggregatable?: boolean;
@@ -529,12 +563,9 @@ export type TableVisualization = {
 	isInsightsEnabled?: boolean;
 	header?: string;
 	headerVisible?: boolean;
-	clearSelectionOnFilter: boolean;
-	events?: Record<string, string | undefined>;
+	handlePatchSent: boolean;
 };
 
-// maximum number of items to open in new tabs simultanously
-const selectionLimitForOpenInNewTab = 10;
 /**
  * Returns an array of all standard, annotation-based, and manifest-based table actions.
  * @param lineItemAnnotation
@@ -551,7 +582,9 @@ export function getTableActions(
 	standardActions: StandardActionsConfiguration["standardActions"],
 	navigationSettings?: NavigationSettingsConfiguration
 ): CombinedAction {
+	// 1. Get actions from annotations
 	const tableActions = getTableAnnotationActions(lineItemAnnotation, visualizationPath, converterContext);
+	// 2. Get actions from manifest
 	const manifestActions = getActionsFromManifest(
 		converterContext.getManifestControlConfiguration<TableManifestConfiguration>(visualizationPath).actions as Record<
 			string,
@@ -603,14 +636,28 @@ export function getTableActions(
 		visibleForContextMenu: OverrideType.overwrite,
 		defaultValuesExtensionFunction: OverrideType.overwrite,
 		command: OverrideType.overwrite,
-		position: OverrideType.overwrite
+		position: OverrideType.overwrite,
+		menu: OverrideType.overwrite
 	};
-	let actions = insertCustomElements(annotationAndStandardActions, nonStandardManifestActions, actionOverwriteConfig);
+	// 3. Get all annotation menu items
+	const annotationMenuActionItems = getAnnotationMenuActionItems(annotationActions);
+	// 4. Find manifest actions which override any annotation menu items
+	const matchingManifestActions = getMatchingManifestAction(annotationMenuActionItems, manifestActions.actions);
+	// 5. Get overridden annotation menu items
+	const overwrittenMenuActionItems = insertCustomElements(annotationMenuActionItems, matchingManifestActions, actionOverwriteConfig);
+	// 6. Override all actions
+	let actions = insertCustomElements(annotationAndStandardActions, nonStandardManifestActions, actionOverwriteConfig) as CustomAction[];
 	actions = insertCustomElements(actions, standardManifestActions, {
 		position: OverrideType.overwrite
 	});
+	// 7. Replace original menu items with their corresponding overridden menu items
+	prepareMenuActions(actions, overwrittenMenuActionItems);
+	// 8. Remove duplicate actions which are menu items
+	actions = removeDuplicateActions(actions);
+	// 9. Hide menus where all menu items are hidden
+	actions = getVisibilityEnablementMenuActions(actions);
 	return {
-		actions,
+		actions: actions,
 		commandActions: manifestActions.commandActions
 	};
 }
@@ -620,22 +667,19 @@ export function getTableActions(
  * @param lineItemAnnotation Collection of data fields for representation in a table or list
  * @param visualizationPath
  * @param converterContext
- * @param navigationSettings
  * @returns Returns all table columns that should be available, regardless of templating or personalization or their origin
  */
 export function getTableColumns(
 	lineItemAnnotation: LineItem,
 	visualizationPath: string,
-	converterContext: ConverterContext<PageContextPathTarget>,
-	navigationSettings?: NavigationSettingsConfiguration
+	converterContext: ConverterContext<PageContextPathTarget>
 ): TableColumn[] {
 	const annotationColumns = getColumnsFromAnnotations(lineItemAnnotation, visualizationPath, converterContext);
 	const manifestColumns = getColumnsFromManifest(
 		converterContext.getManifestControlConfiguration<TableManifestConfiguration>(visualizationPath).columns ?? {},
 		annotationColumns,
 		converterContext,
-		converterContext.getAnnotationEntityType(lineItemAnnotation),
-		navigationSettings
+		converterContext.getAnnotationEntityType(lineItemAnnotation)
 	);
 
 	const tableColumns: TableColumn[] = insertCustomElements(
@@ -787,7 +831,14 @@ export function updateTableVisualizationForType(
 				} else {
 					tableVisualization.requestAtLeast = ["HasActiveEntity"];
 				}
+
+				// We always load 'HasDraftEntity' in a LR because it's needed to navigate to the draft instance if there's one when clicking on the active instance
+				if (ModelHelper.isDraftRoot(converterContext.getEntitySet())) {
+					tableVisualization.requestAtLeast.push("HasDraftEntity");
+				}
 			}
+		} else {
+			Log.error(`Aggregation not supported for this entity type: ${entityType.name}`);
 		}
 		tableVisualization.control.type = "GridTable"; // AnalyticalTable isn't a real type for the MDC:Table, so we always switch back to Grid
 	} else if (tableVisualization.control.type === "ResponsiveTable") {
@@ -808,6 +859,15 @@ export function updateTableVisualizationForType(
 		tableVisualization.annotation.allowDropBetweenNodes =
 			!!entityType.annotations.Hierarchy?.[`RecursiveHierarchyActions#${tableVisualization.control.hierarchyQualifier ?? ""}`]
 				?.ChangeNextSiblingAction;
+
+		// We always load 'HasDraftEntity' in a LR because it's needed to navigate to the draft instance if there's one when clicking on the active instance
+		if (ModelHelper.isDraftRoot(converterContext.getEntitySet())) {
+			if (tableVisualization.requestAtLeast) {
+				tableVisualization.requestAtLeast.push("HasDraftEntity");
+			} else {
+				tableVisualization.requestAtLeast = ["HasDraftEntity"];
+			}
+		}
 	}
 
 	if (tableVisualization.control.enableUploadPlugin) {
@@ -828,11 +888,6 @@ export function updateTableVisualizationForType(
 			uploadAction: uploadAction
 		};
 	}
-
-	// We don't keep table selection after searching/filtering, except in responsive tables
-	if (tableVisualization.control.type !== "ResponsiveTable") {
-		tableVisualization.clearSelectionOnFilter = true;
-	}
 }
 
 /**
@@ -940,52 +995,99 @@ function findColumnByPath(path: string, tableColumns: TableColumn[]): TableColum
 }
 /**
  * Sets the 'unit', 'textArrangement', 'timezone' and 'exportsettings' properties in columns when necessary.
- * @param entityType The entity type displayed in the table
+ * @param converterContext The instance of the converter context
  * @param tableColumns The columns to be updated
  */
-export function updateLinkedProperties(entityType: EntityType, tableColumns: TableColumn[]): void {
+export function updateLinkedProperties(converterContext: ConverterContext, tableColumns: TableColumn[]): void {
+	const dataModelObjectPath = converterContext.getConverterContextFor(converterContext.getContextPath()).getDataModelObjectPath();
 	tableColumns.forEach((oColumn) => {
 		const tableColumn = oColumn as AnnotationTableColumn;
 		if (tableColumn.propertyInfos === undefined && tableColumn.relativePath) {
-			const property = entityType.entityProperties.find((prop: Property) => prop.name === tableColumn.relativePath);
+			const propertyDataModelObjectPath = enhanceDataModelPath<Property>(dataModelObjectPath, tableColumn.relativePath);
+			const property = propertyDataModelObjectPath.targetObject;
 			if (property) {
-				const unitProperty = getAssociatedCurrencyProperty(property) || getAssociatedUnitProperty(property);
+				addCurrencyOrUoMToProperty(property, propertyDataModelObjectPath, tableColumns, tableColumn);
 				const timezoneProperty = getAssociatedTimezoneProperty(property);
 				const timezone = property?.annotations?.Common?.Timezone;
-				if (unitProperty) {
-					const unitColumn = findColumnByPath(unitProperty.name, tableColumns);
-					tableColumn.unit = unitColumn?.name;
-				} else {
-					const unit = property?.annotations?.Measures?.ISOCurrency || property?.annotations?.Measures?.Unit;
-					if (unit) {
-						tableColumn.unitText = `${unit}`;
-					}
-				}
 				if (timezoneProperty) {
 					const oTimezoneColumn = findColumnByPath(timezoneProperty.name, tableColumns);
 					tableColumn.timezone = oTimezoneColumn?.name;
 				} else if (timezone) {
 					tableColumn.timezoneText = timezone.toString();
 				}
-				const displayMode = getDisplayMode(property),
-					textAnnotation = property.annotations.Common?.Text;
-				if (isPathAnnotationExpression(textAnnotation) && displayMode !== "Value") {
-					const textColumn = findColumnByPath(textAnnotation.path, tableColumns);
-					if (textColumn && textColumn.name !== tableColumn.name) {
-						tableColumn.textArrangement = {
-							textProperty: textColumn.name,
-							mode: displayMode
-						};
-						// If text properties are used but hidden, we must include them to the export as there are used in the paste
-						if (!textColumn.exportSettings) {
-							textColumn.exportSettings = { type: "String" };
-						}
-					}
-				}
+				addTextArrangentInfoToProperty(property, propertyDataModelObjectPath, tableColumns, tableColumn);
 			}
 		}
 	});
 }
+
+/**
+ * Adds the "unit" property into the columns when neccesary for columns with unit of measure and currencies.
+ * @param property The property referenced on the column
+ * @param dataModelObjectPath The property DataModelObjectPath.
+ * @param tableColumns The list of columns displayed on the table
+ * @param tableColumn The table column which adds the currency or unit
+ * @returns The updated property with the UoM or currency
+ */
+
+function addCurrencyOrUoMToProperty(
+	property: Property,
+	propertyDataModelObjectPath: DataModelObjectPath<Property>,
+	tableColumns: TableColumn[],
+	tableColumn: AnnotationTableColumn
+): void {
+	const currencyOrUoMProperty = getAssociatedCurrencyPropertyPath(property) || getAssociatedUnitPropertyPath(property);
+	if (currencyOrUoMProperty) {
+		const currencyOrUoMPropertyDataModelObjectPath = enhanceDataModelPath<Property>(propertyDataModelObjectPath, currencyOrUoMProperty);
+		const currencyOrUoMRelativePath = getContextRelativeTargetObjectPath(currencyOrUoMPropertyDataModelObjectPath);
+		if (currencyOrUoMRelativePath) {
+			const unitColumn = findColumnByPath(currencyOrUoMRelativePath, tableColumns);
+			tableColumn.unit = unitColumn?.name;
+		}
+	} else {
+		const unit = property?.annotations?.Measures?.ISOCurrency || property?.annotations?.Measures?.Unit;
+		if (unit) {
+			tableColumn.unitText = `${unit}`;
+		}
+	}
+}
+
+/**
+ * Add the "textArrangement" object to columns when necessary for columns containing text, such as descriptions.
+ * @param property The property referenced by the column
+ * @param dataModelObjectPath The property DataModelObjectPath.
+ * @param tableColumns The list of columns displayed on the table
+ * @param tableColumn The table column which adds the text
+ * @returns The updated property with text arrangement information
+ */
+
+function addTextArrangentInfoToProperty(
+	property: Property,
+	propertyDataModelObjectPath: DataModelObjectPath<Property>,
+	tableColumns: TableColumn[],
+	tableColumn: AnnotationTableColumn
+): void {
+	const displayMode = getDisplayMode(property),
+		textPropertyPath = getAssociatedTextPropertyPath(property);
+	if (textPropertyPath && displayMode !== "Value") {
+		const textPropertyDataModelObjectPath = enhanceDataModelPath<Property>(propertyDataModelObjectPath, textPropertyPath);
+		const textRelativePath = getContextRelativeTargetObjectPath(textPropertyDataModelObjectPath);
+		if (textRelativePath) {
+			const textColumn = findColumnByPath(textRelativePath, tableColumns);
+			if (textColumn && textColumn.name !== tableColumn.name) {
+				tableColumn.textArrangement = {
+					textProperty: textColumn.name,
+					mode: displayMode
+				};
+				// If text properties are used but hidden, we must include them to the export as there are used in the paste
+				if (!textColumn.exportSettings) {
+					textColumn.exportSettings = { type: "String" };
+				}
+			}
+		}
+	}
+}
+
 function getSemanticKeysAndTitleInfo(converterContext: ConverterContext<PageContextPathTarget>): {
 	headerInfoTitlePath: string;
 	semanticKeyColumns: string[];
@@ -1024,7 +1126,7 @@ export function createTableVisualization(
 	const { navigationPropertyPath } = splitPath(visualizationPath);
 	const navigationTargetPath = getNavigationTargetPath(converterContext, navigationPropertyPath);
 	const navigationSettings = converterContext.getManifestWrapper().getNavigationConfiguration(navigationTargetPath);
-	const columns = getTableColumns(lineItemAnnotation, visualizationPath, converterContext, navigationSettings);
+	const columns = getTableColumns(lineItemAnnotation, visualizationPath, converterContext);
 	const operationAvailableMap = getOperationAvailableMap(lineItemAnnotation, converterContext);
 	const semanticKeysAndHeaderInfoTitle = getSemanticKeysAndTitleInfo(converterContext);
 	const standardActionsConfiguration = getStandardActionsConfiguration(
@@ -1058,7 +1160,7 @@ export function createTableVisualization(
 		type: VisualizationType.Table,
 		annotation: tableAnnotation,
 		control: tableManifestConfig,
-		actions: removeDuplicateActions(tableActions.actions),
+		actions: tableActions.actions,
 		commandActions: tableActions.commandActions,
 		columns: columns,
 		operationAvailableMap: JSON.stringify(operationAvailableMap),
@@ -1071,15 +1173,9 @@ export function createTableVisualization(
 		header: header,
 		headerVisible: tableManifestConfig.headerVisible,
 		requestAtLeast: createRequestedProperties(lineItemAnnotation, converterContext, operationAvailable, presentationVariantAnnotation),
-		clearSelectionOnFilter: false,
-		events: {
-			patchSent:
-				converterContext.getManifestWrapper().getTemplateType() !== TemplateType.ListReport
-					? ".editFlow.handlePatchSent"
-					: undefined
-		}
+		handlePatchSent: converterContext.getManifestWrapper().getTemplateType() !== TemplateType.ListReport
 	};
-	updateLinkedProperties(converterContext.getAnnotationEntityType(lineItemAnnotation), columns);
+	updateLinkedProperties(converterContext, columns);
 	updateTableVisualizationForType(
 		oVisualization,
 		converterContext.getAnnotationEntityType(lineItemAnnotation),
@@ -1136,15 +1232,9 @@ export function createDefaultTableVisualization(
 		enable$$getKeepAliveContext: true,
 		header: tableManifestConfig.header,
 		headerVisible: tableManifestConfig.headerVisible,
-		clearSelectionOnFilter: false,
-		events: {
-			patchSent:
-				converterContext.getManifestWrapper().getTemplateType() !== TemplateType.ListReport
-					? ".editFlow.handlePatchSent"
-					: undefined
-		}
+		handlePatchSent: converterContext.getManifestWrapper().getTemplateType() !== TemplateType.ListReport
 	};
-	updateLinkedProperties(converterContext.getEntityType(), columns);
+	updateLinkedProperties(converterContext, columns);
 	updateTableVisualizationForType(oVisualization, converterContext.getEntityType(), converterContext);
 	return oVisualization;
 }
@@ -1438,9 +1528,19 @@ export function getSelectionMode(
 	cutButtonVisibilityExpression: BindingToolkitExpression<boolean> = constant(false)
 ): string | undefined {
 	const tableManifestSettings = converterContext.getManifestControlConfiguration<TableManifestConfiguration>(visualizationPath);
+	const tableType = tableManifestSettings.tableSettings?.type;
 	let selectionMode = tableManifestSettings.tableSettings?.selectionMode;
-	// If the selection mode is forced to 'None' in the manifest/macro table parameters, we ignore the rest of the logic and keep it as specified
+
+	// The collapse/Expand action of a tree table is a bound action, as a result, a tree table should always have a selection mode to "Multi" when no selectionMode has been set in the manifest
+	if (tableType === "TreeTable" && !selectionMode) {
+		return SelectionMode.Multi;
+	}
+
+	// If the selection mode is forced to 'None' in the manifest/macro table parameters, we keep it unless here is a delete button
 	if (!lineItemAnnotation || selectionMode === SelectionMode.None) {
+		if (targetCapabilities.isDeletable && deleteButtonVisibilityExpression) {
+			return compileExpression(ifElse(deleteButtonVisibilityExpression, constant(SelectionMode.Multi), constant(SelectionMode.None)));
+		}
 		return SelectionMode.None;
 	}
 	if (selectionMode === SelectionMode.ForceMulti) {
@@ -1572,44 +1672,20 @@ function getTableAnnotationActions(
 	lineItemAnnotation: LineItem,
 	visualizationPath: string,
 	converterContext: ConverterContext<PageContextPathTarget>
-): { tableActions: AnnotationAction[] } {
-	const tableActions: AnnotationAction[] = [];
+): { tableActions: Array<AnnotationAction | AnnotationActionGroup> } {
+	const tableActions: Array<AnnotationAction | AnnotationActionGroup> = [];
 	const copyDataField = getCopyAction(
 		lineItemAnnotation.filter((dataField) => {
 			return dataFieldIsCopyAction(dataField as DataFieldForActionTypes);
 		}) as DataFieldForActionTypes[]
 	);
-	const sEntityType = converterContext.getEntityType().fullyQualifiedName;
-	const visibleExpression = function (
-		dataField: DataFieldForAction | DataFieldForIntentBasedNavigation | undefined
-	): BindingToolkitExpression<boolean> {
-		return not(
-			equal(
-				getExpressionFromAnnotation(
-					dataField?.annotations?.UI?.Hidden,
-					[],
-					undefined,
-					converterContext.getRelativeModelPathFunction()
-				),
-				true
-			)
-		);
-	};
-	// For the context menu, the visibility should also consider the 'inactiveContext' property:
-	// only when at least one selected context is active (i.e. "contextmenu/inactiveContext" is false), the action should be visible in the context menu
-	// This is only relevant when the table manifest setting "creationMode" is "InlineCreationRows"
-	const visibleForContextMenuExpression = function (
-		dataField: DataFieldForAction | DataFieldForIntentBasedNavigation | undefined
-	): BindingToolkitExpression<boolean> {
-		return and(visibleExpression(dataField), equal(pathInModel("contextmenu/inactiveContext", "internal"), false));
-	};
 	if (copyDataField) {
 		tableActions.push({
 			type: ActionType.Copy,
 			annotationPath: converterContext.getEntitySetBasedAnnotationPath(copyDataField.fullyQualifiedName),
 			key: KeyHelper.generateKeyFromDataField(copyDataField),
-			visible: compileExpression(visibleExpression(copyDataField)),
-			visibleForContextMenu: compileExpression(visibleForContextMenuExpression(copyDataField)),
+			visible: compileExpression(visibleExpression(copyDataField, converterContext)),
+			visibleForContextMenu: compileExpression(visibleForContextMenuExpression(copyDataField, converterContext)),
 			text: copyDataField.Label?.toString() ?? Library.getResourceBundleFor("sap.fe.core")!.getText("C_COMMON_COPY"),
 			isNavigable: true
 		});
@@ -1624,39 +1700,75 @@ function getTableAnnotationActions(
 				dataField.Inline?.valueOf() !== true &&
 				dataField.Determining?.valueOf() !== true
 			) {
-				switch (dataField.$Type) {
-					case UIAnnotationTypes.DataFieldForAction:
-						const tableAction: AnnotationAction = {
-							type: ActionType.DataFieldForAction,
-							annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
-							key: KeyHelper.generateKeyFromDataField(dataField),
-							visible: compileExpression(visibleExpression(dataField)),
-							visibleForContextMenu: compileExpression(visibleForContextMenuExpression(dataField)),
-							isNavigable: true
-						};
-						if (_useEnabledExpression(dataField, sEntityType)) {
-							tableAction.enabled = getEnabledForAnnotationAction(converterContext, dataField.ActionTarget, true);
-						}
-						tableActions.push(tableAction);
-						break;
-					case UIAnnotationTypes.DataFieldForIntentBasedNavigation:
-						tableActions.push({
-							type: ActionType.DataFieldForIntentBasedNavigation,
-							annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
-							key: KeyHelper.generateKeyFromDataField(dataField),
-							visible: compileExpression(visibleExpression(dataField)),
-							visibleForContextMenu: compileExpression(visibleForContextMenuExpression(dataField))
-						});
-						break;
-					default:
-						break;
+				const tableAction = getDataFieldAnnotationAction(dataField, converterContext);
+				if (tableAction) {
+					tableActions.push(tableAction);
+				}
+			} else if (isDataFieldForActionGroup(dataField)) {
+				const dataFieldGroup = getDataFieldAnnotationAction(dataField, converterContext);
+				if (dataFieldGroup) {
+					tableActions.push(dataFieldGroup);
 				}
 			}
 		});
+
 	return {
 		tableActions
 	};
 }
+
+// For the context menu, the visibility should also consider the 'inactiveContext' property:
+// only when at least one selected context is active (i.e. "contextmenu/inactiveContext" is false), the action should be visible in the context menu
+// This is only relevant when the table manifest setting "creationMode" is "InlineCreationRows"
+function visibleForContextMenuExpression(
+	dataField: DataFieldForAction | DataFieldForIntentBasedNavigation | DataFieldForActionGroup | undefined,
+	converterContext: ConverterContext<PageContextPathTarget>
+): BindingToolkitExpression<boolean> {
+	return and(visibleExpression(dataField, converterContext), equal(pathInModel("contextmenu/inactiveContext", "internal"), false));
+}
+
+function getDataFieldAnnotationAction(
+	dataField: DataFieldAbstractTypes,
+	converterContext: ConverterContext<PageContextPathTarget>
+): AnnotationAction | AnnotationActionGroup | void {
+	switch (dataField.$Type) {
+		case UIAnnotationTypes.DataFieldForAction:
+			const tableAction: AnnotationAction = {
+				type: ActionType.DataFieldForAction,
+				annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
+				key: KeyHelper.generateKeyFromDataField(dataField),
+				visible: compileExpression(visibleExpression(dataField, converterContext)),
+				visibleForContextMenu: compileExpression(visibleForContextMenuExpression(dataField, converterContext)),
+				isNavigable: true
+			};
+			const sEntityType = converterContext.getEntityType().fullyQualifiedName;
+			if (_useEnabledExpression(dataField, sEntityType)) {
+				tableAction.enabled = getEnabledForAnnotationAction(converterContext, dataField.ActionTarget, true);
+			}
+			return tableAction;
+		case UIAnnotationTypes.DataFieldForIntentBasedNavigation:
+			return {
+				type: ActionType.DataFieldForIntentBasedNavigation,
+				annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
+				key: KeyHelper.generateKeyFromDataField(dataField),
+				visible: compileExpression(visibleExpression(dataField, converterContext)),
+				visibleForContextMenu: compileExpression(visibleForContextMenuExpression(dataField, converterContext))
+			};
+		case UIAnnotationTypes.DataFieldForActionGroup:
+			return {
+				type: ActionType.Menu,
+				key: KeyHelper.generateKeyFromDataField(dataField),
+				id: KeyHelper.generateKeyFromDataField(dataField),
+				text: dataField.Label?.toString(),
+				visible: compileExpression(visibleExpression(dataField, converterContext)),
+				visibleForContextMenu: compileExpression(visibleForContextMenuExpression(dataField, converterContext)),
+				menu: dataField.Actions.map((action) => getDataFieldAnnotationAction(action, converterContext))
+			} as AnnotationActionGroup;
+		default:
+			return;
+	}
+}
+
 /**
  * Generate the bindingExpression for the highlight rowSetting parameter.
  * @param criticalityAnnotation Path or value of the criticality
@@ -1685,7 +1797,8 @@ function getHighlightRowBinding(
 			isDraftRootOrNode && Entity.HasActive,
 			isDraftRootOrNode && Entity.IsActive,
 			`${isDraftRootOrNode}`,
-			pathInModel("@$ui5.fe.contextPath")
+			pathInModel("@$ui5.fe.contextPath"),
+			UI.IsInactive
 		],
 		tableFormatters.rowHighlighting,
 		targetEntityType
@@ -1775,31 +1888,34 @@ const _getRowConfigurationProperty = function (
 	converterContext: ConverterContext<PageContextPathTarget>,
 	navigationSettings: NavigationSettingsConfiguration,
 	targetPath: string,
-	tableType: TableType
+	tableType: TableType,
+	disableNavigation?: boolean
 ): RowConfiguration {
-	let pressProperty, openInNewTabPressProperty, navigationTarget;
+	let navigationInfo: RowNavigationInfo | undefined;
 	let criticalityProperty: BindingToolkitExpression<MessageType> = constant(MessageType.None);
 	const targetEntityType = converterContext.getEntityType();
-	if (navigationSettings && lineItemAnnotation) {
-		navigationTarget = navigationSettings.display?.target || navigationSettings.detail?.outbound;
+	const criticalityAnnotation = lineItemAnnotation?.annotations?.UI?.Criticality;
+	if (!disableNavigation && navigationSettings && lineItemAnnotation) {
+		const navigationTarget = navigationSettings.display?.target || navigationSettings.detail?.outbound;
 		const targetEntitySet = converterContext.getEntitySet();
 		criticalityProperty = getHighlightRowBinding(
-			lineItemAnnotation.annotations?.UI?.Criticality,
+			criticalityAnnotation,
 			!!ModelHelper.getDraftRoot(targetEntitySet) || !!ModelHelper.getDraftNode(targetEntitySet),
 			targetEntityType
 		);
 		if (navigationTarget) {
-			pressProperty = `API.onChevronPressNavigateOutBound($event, $controller ,'${navigationTarget}', \${$parameters>bindingContext})`;
-			openInNewTabPressProperty = `.onOpenInNewTabNavigateOutBound('${navigationTarget}', %{internal>contextmenu/selectedContexts}, "", ${selectionLimitForOpenInNewTab})`;
+			navigationInfo = { type: "Outbound", navigationTarget };
 		}
 		if (!navigationTarget && navigationSettings.detail?.route) {
-			const editable =
-				ModelHelper.getDraftRoot(targetEntitySet) || ModelHelper.getDraftNode(targetEntitySet)
-					? "!${$parameters>bindingContext}.getProperty('IsActiveEntity')"
-					: "undefined";
-			const recreateContext = tableType === "AnalyticalTable" ? ", recreateContext: true" : "";
-			pressProperty = `API.onTableRowPress($event, $controller, \${$parameters>bindingContext}, { callExtension: true, targetPath: '${targetPath}', editable: ${editable} ${recreateContext} })`; //Need to access to DraftRoot and DraftNode !!!!!!!
-			openInNewTabPressProperty = `API.onOpenInNewTabPress($event, $controller, %{internal>contextmenu/selectedContexts}, { callExtension: true, targetPath: '${targetPath}', navMode: 'openInNewTab' }, ${selectionLimitForOpenInNewTab})`;
+			const checkEditable =
+				ModelHelper.getDraftRoot(targetEntitySet) !== undefined || ModelHelper.getDraftNode(targetEntitySet) !== undefined;
+			navigationInfo = {
+				type: "Navigation",
+				routePath: navigationSettings.detail.route,
+				targetPath,
+				checkEditable,
+				recreateContext: tableType === "AnalyticalTable"
+			};
 		}
 	}
 	const rowNavigatedExpression: BindingToolkitExpression<boolean> = formatResult(
@@ -1808,11 +1924,11 @@ const _getRowConfigurationProperty = function (
 		targetEntityType
 	);
 	return {
-		press: pressProperty,
-		openInNewTabPress: openInNewTabPressProperty,
-		action: pressProperty ? "Navigation" : undefined,
+		navigationInfo,
+		action: navigationInfo ? "Navigation" : undefined,
 		rowHighlighting: compileExpression(criticalityProperty),
 		rowNavigated: compileExpression(rowNavigatedExpression),
+		rowCriticalityForInsights: criticalityAnnotation ? criticalityExpressionForIntegrationCards(criticalityAnnotation) : undefined,
 		visible: compileExpression(not(UI.IsInactive))
 	};
 };
@@ -1960,6 +2076,7 @@ export const getColumnsFromEntityType = function (
  * @param restrictionsOnProperties The existing restrictions on properties
  * @param tableCreationMode The creation mode of the table
  * @param relatedPropertiesInfo The properties identified so far for the column
+ * @param relativePathForMultiValue The MDC path used for the 1:n property to allow filtering from MDC
  * @returns The annotation column definition
  */
 const getColumnDefinitionFromProperty = function (
@@ -1973,10 +2090,10 @@ const getColumnDefinitionFromProperty = function (
 	displayModeOfDescriptionPropertiesMap: Record<string, DisplayMode>,
 	restrictionsOnProperties?: RestrictionsOnProperties,
 	tableCreationMode?: CreationMode,
-	relatedPropertiesInfo?: ComplexPropertyInfo
+	relatedPropertiesInfo?: ComplexPropertyInfo,
+	relativePathForMultiValue?: string
 ): AnnotationTableColumn | TechnicalColumn {
-	const name = useDataFieldPrefix ? relativePath : `Property::${relativePath}`;
-	const key = (useDataFieldPrefix ? "DataField::" : "Property::") + replaceSpecialChars(relativePath);
+	let name, key;
 	const semanticObjectAnnotationPath = getSemanticObjectPath(converterContext, property);
 	const isHidden = isReferencePropertyStaticallyHidden(property);
 	const groupPath: string | undefined = property.name ? _sliceAtSlash(property.name, true, false) : undefined;
@@ -2000,6 +2117,14 @@ const getColumnDefinitionFromProperty = function (
 	const availability: AvailabilityType =
 		!availableForAdaptation || isHidden || displayModeOfDescriptionPropertiesMap[relativePath] ? "Hidden" : "Adaptation";
 	const collectedNavigationPropertyLabels: string[] | undefined = _getCollectedNavigationPropertyLabels(relativePath, converterContext);
+	if (relativePathForMultiValue) {
+		name = relativePathForMultiValue;
+		key = "DataField::" + replaceSpecialChars(relativePathForMultiValue);
+		relativePath = relativePathForMultiValue;
+	} else {
+		name = useDataFieldPrefix ? relativePath : `Property::${relativePath}`;
+		key = (useDataFieldPrefix ? "DataField::" : "Property::") + replaceSpecialChars(relativePath);
+	}
 
 	const column: AnnotationTableColumn = {
 		key: key,
@@ -2133,16 +2258,20 @@ const removeUndefinedFromExportSettings = function (exportSettings: ColumnExport
  * @param annotationColumns The array of columns created based on LineItem annotations.
  * @param columnsToBeCreated The columns to be created
  * @param columnInfo The column definition
+ * @param columnName The name of the column
  */
 function updatePropertyLabel(
 	annotationColumns: AnnotationTableColumn[],
 	columnsToBeCreated: Record<string, Property>,
-	columnInfo: AnnotationTableColumn
+	columnInfo: AnnotationTableColumn,
+	columnName?: string
 ): void {
-	const linkedAnnotationColumns = annotationColumns.filter((col) => col.propertyInfos?.includes(columnInfo.relativePath));
+	const linkedAnnotationColumns = annotationColumns.filter(
+		(col) => col.propertyInfos?.includes(columnInfo.relativePath) || (columnName && col.propertyInfos?.includes(columnName))
+	);
 	if (
 		linkedAnnotationColumns?.length === 1 &&
-		columnsToBeCreated[columnInfo.relativePath] &&
+		(columnsToBeCreated[columnInfo.relativePath] || (columnName && columnsToBeCreated[columnName])) &&
 		linkedAnnotationColumns[0].propertyInfos?.length === 1
 	) {
 		columnInfo.label = linkedAnnotationColumns[0].label;
@@ -2386,7 +2515,29 @@ const _createRelatedColumns = function (
 			annotationPath = converterContext.getAbsoluteAnnotationPath(name),
 			// Check whether the related column already exists.
 			relatedColumn = existingColumns.find((column) => column.name === name);
-		if (relatedColumn === undefined) {
+		const dataModelObjectPath = converterContext.getConverterContextFor(converterContext.getContextPath()).getDataModelObjectPath();
+		const propertyObjectPath = enhanceDataModelPath<PageContextPathTarget>(dataModelObjectPath, name);
+		if (isMultiValueField(propertyObjectPath)) {
+			const newNameRelativeTargetPath = getContextRelativeTargetObjectPath(propertyObjectPath, false, true);
+			const column = getColumnDefinitionFromProperty(
+				property,
+				annotationPath,
+				name,
+				true,
+				false,
+				aggregationHelper,
+				converterContext,
+				displayModeOfDescriptionPropertiesMap,
+				restrictionsOnProperties,
+				tableCreationMode,
+				undefined,
+				newNameRelativeTargetPath
+			);
+			computeHiddenOnRelatedColumns(existingColumns, name, column);
+			updatePropertyLabel(existingColumns, columnsToBeCreated, column, name);
+			relatedColumns.push(column);
+			relatedPropertyNameMap[name] = newNameRelativeTargetPath ?? name;
+		} else if (relatedColumn === undefined) {
 			// Case 1: Key contains DataField prefix to ensure all property columns have the same key format.
 			// New created property column is set to hidden.
 			const column = getColumnDefinitionFromProperty(
@@ -2610,12 +2761,22 @@ const _isColumnMultiValued = function (
  * @param dataField The data field being processed
  * @param propertyPath The property path
  * @param nonSortableColumns Collection of non-sortable column names as per annotation
+ * @param relatedPropertiesInfo The related properties linked to the column
  * @returns True if the column is sortable
  */
-const _isColumnSortable = function (dataField: DataFieldAbstractTypes, propertyPath: string, nonSortableColumns: string[]): boolean {
+const _isColumnSortable = function (
+	dataField: DataFieldAbstractTypes,
+	propertyPath: string,
+	nonSortableColumns: string[],
+	relatedPropertiesInfo: ComplexPropertyInfo
+): boolean {
 	return (
 		!nonSortableColumns.includes(propertyPath) && // Column is not marked as non-sortable via annotation
-		(dataField.$Type === UIAnnotationTypes.DataField ||
+		(((dataField.$Type === UIAnnotationTypes.DataField || dataField.$Type === UIAnnotationTypes.DataFieldForAnnotation) &&
+			Object.keys(relatedPropertiesInfo.properties).some((propName) => {
+				const isHidden = isReferencePropertyStaticallyHidden(relatedPropertiesInfo.properties[propName].annotationProperty);
+				return !isHidden && !nonSortableColumns.includes(propName);
+			})) ||
 			dataField.$Type === UIAnnotationTypes.DataFieldWithUrl ||
 			dataField.$Type === UIAnnotationTypes.DataFieldWithIntentBasedNavigation ||
 			dataField.$Type === UIAnnotationTypes.DataFieldWithAction)
@@ -2964,7 +3125,9 @@ const getColumnsFromAnnotations = function (
 				// for charts
 				visualSettings.widthCalculation = null;
 			}
-			const sortable = !isMultiValue && _isColumnSortable(dataField, relativePath, restrictionsOnProperties.nonSortableProperties);
+			const sortable =
+				!isMultiValue &&
+				_isColumnSortable(dataField, relativePath, restrictionsOnProperties.nonSortableProperties, relatedPropertiesInfo);
 			const availability = isReferencePropertyStaticallyHidden(dataField) ? "Hidden" : "Default";
 			const column: AnnotationTableColumn = {
 				key: KeyHelper.generateKeyFromDataField(dataField),
@@ -3248,18 +3411,16 @@ const _appendCustomTemplate = function (properties: string[] | undefined, export
  * @param annotationColumns
  * @param converterContext
  * @param entityType
- * @param navigationSettings
  * @returns The columns from the manifest
  */
 const getColumnsFromManifest = function (
 	columns: Record<string, CustomDefinedTableColumn | CustomDefinedTableColumnForOverride>,
 	annotationColumns: AnnotationTableColumn[],
 	converterContext: ConverterContext<PageContextPathTarget>,
-	entityType: EntityType,
-	navigationSettings?: NavigationSettingsConfiguration
+	entityType: EntityType
 ): Record<string, ManifestColumn> {
 	const internalColumns: Record<string, ManifestColumn> = {};
-	function isAnnotationColumn(
+	function isColumnOverride(
 		column: CustomDefinedTableColumn | CustomDefinedTableColumnForOverride,
 		key: string
 	): column is CustomDefinedTableColumnForOverride {
@@ -3279,6 +3440,7 @@ const getColumnsFromManifest = function (
 					prop.sortable = !restrictionsOnProperties.nonSortableProperties.includes(property.replace("Property::", ""));
 					prop.isGroupable = prop.sortable;
 					prop.filterable = !restrictionsOnProperties.nonFilterableProperties.includes(property.replace("Property::", ""));
+					prop.isPartOfCustomColumn = true;
 				}
 			});
 		});
@@ -3297,16 +3459,14 @@ const getColumnsFromManifest = function (
 			},
 			caseSensitive: isFilteringCaseSensitive(converterContext)
 		};
-		if (isAnnotationColumn(manifestColumn, key)) {
+		if (isColumnOverride(manifestColumn, key)) {
 			const propertiesToOverwriteAnnotationColumn: CustomElement<AnnotationTableColumnForOverride> = {
 				...baseTableColumn,
 				importance: manifestColumn?.importance,
 				horizontalAlign: manifestColumn?.horizontalAlign,
 				availability: manifestColumn?.availability,
 				type: ColumnType.Annotation,
-				isNavigable: isAnnotationColumn(manifestColumn, key)
-					? undefined
-					: isActionNavigable(manifestColumn, navigationSettings, true),
+				isNavigable: undefined,
 				settings: manifestColumn.settings,
 				formatOptions: _getDefaultFormatOptionsForTable(manifestColumn.formatOptions),
 				exportSettings: getCustomExportSettings(
@@ -3390,54 +3550,6 @@ const getColumnsFromManifest = function (
 	return internalColumns;
 };
 
-/**
- * Adds references to columns that are needed to display the draft indicator column properly.
- * @param draftIndicatorColumn
- * @param tableColumns
- * @param converterContext
- */
-function addReferencesForDraftIndicatorColumn(
-	draftIndicatorColumn: ComputedTableColumn,
-	tableColumns: TableColumn[],
-	converterContext: ConverterContext<PageContextPathTarget>
-): void {
-	function createRelatedColumn(propertyPath: string): void {
-		const key = "Property_Technical::" + propertyPath.replace(/\//g, ":");
-		const newColumn: TechnicalColumn = {
-			key,
-			name: key,
-			annotationPath: converterContext.getAbsoluteAnnotationPath(propertyPath),
-			relativePath: propertyPath,
-			isGroupable: false,
-			sortable: false,
-			availability: "Hidden",
-			caseSensitive: false,
-			type: ColumnType.Annotation,
-			extension: {
-				technicallyAggregatable: false,
-				technicallyGroupable: true
-			}
-		};
-		tableColumns.push(newColumn);
-		draftIndicatorColumn.propertyInfos!.push(key);
-	}
-
-	draftIndicatorColumn.propertyInfos = [];
-	createRelatedColumn("HasDraftEntity");
-	createRelatedColumn("DraftAdministrativeData/InProcessByUser");
-	createRelatedColumn("DraftAdministrativeData/LastChangedByUser");
-	createRelatedColumn("DraftAdministrativeData/LastChangeDateTime");
-
-	const draftAdminDataProperties = enhanceDataModelPath(converterContext.getDataModelObjectPath(), "DraftAdministrativeData")
-		.targetEntityType.entityProperties;
-	if (draftAdminDataProperties.find((prop) => prop.name === "InProcessByUserDescription")) {
-		createRelatedColumn("DraftAdministrativeData/InProcessByUserDescription");
-	}
-	if (draftAdminDataProperties.find((prop) => prop.name === "LastChangedByUserDescription")) {
-		createRelatedColumn("DraftAdministrativeData/LastChangedByUserDescription");
-	}
-}
-
 /**
  * Adds computed columns such as the draft status and situations status.
  * @param tableColumns The table columns collected so far
@@ -3531,11 +3643,6 @@ export function addComputedColumns(
 			columnIndexToInsertAfter = tableColumns.findIndex((column) => column.availability !== "Hidden");
 		}
 		tableColumns.splice(columnIndexToInsertAfter + 1, 0, draftIndicatorColumn);
-
-		// On an analytical table, we need to explicitely load some data for the draft indicator column --> we add referenced columns for that
-		if (tableType === "AnalyticalTable") {
-			addReferencesForDraftIndicatorColumn(draftIndicatorColumn, tableColumns, converterContext);
-		}
 	}
 
 	return tableColumns;
@@ -3662,7 +3769,7 @@ function getInitialExpansionLevel(presentationVariantAnnotation: PresentationVar
 		return undefined;
 	}
 	const level = presentationVariantAnnotation.InitialExpansionLevel?.valueOf();
-	return typeof level === "number" ? level : undefined;
+	return typeof level === "number" ? level + 1 : undefined;
 }
 /**
  * Converts an array of propertyPath to an array of propertyInfo names.
@@ -3727,6 +3834,11 @@ function _updatePropertyInfosWithAggregatesDefinitions(tableVisualization: Table
 			const aggregatablePropertyDefinition = tableVisualization.analyticsExtensions![aggregatablePropertyName];
 			column.aggregatable = !aggregatablePropertyDefinition.fromGroupableProperty;
 			column.extension = aggregatablePropertyDefinition ?? {};
+			if (!column.isGroupable && !column.aggregatable) {
+				// The column is neither aggregatable nor groupable --> it's a hidden column to allow filtering in P13N
+				// We need to remove additionalProperties, as it's not needed and causes an error in the MDC table code
+				delete column.extension.additionalProperties;
+			}
 		}
 		if (column.additionalPropertyInfos?.length) {
 			column.additionalPropertyInfos.forEach((additionalPropertyInfo) => {
@@ -3931,7 +4043,8 @@ export function getTableAnnotationConfiguration(
 			converterContext,
 			navigationSettings,
 			navigationTargetPath,
-			tableManifestConfiguration.type
+			tableManifestConfiguration.type,
+			tableManifestConfiguration.analyticalConfiguration?.aggregationOnLeafLevel // the navigation is disabled if the aggregationOnLeafLevel is set to true
 		),
 		p13nMode,
 		isInsertUpdateActionsTemplated: standardActionsConfiguration.isInsertUpdateActionsTemplated,
@@ -4091,7 +4204,7 @@ function _getTableMode(
 		} else {
 			return {
 				rowCountMode: tableSettings.rowCountMode ?? "Fixed",
-				rowCount: tableSettings.rowCount ? tableSettings.rowCount : 5
+				rowCount: tableSettings.rowCount ?? (tableType === "GridTable" ? 5 : 10)
 			};
 		}
 	} else {
@@ -4402,7 +4515,6 @@ export function getTableManifestConfiguration(
 	const enableAutoColumnWidth = !_manifestWrapper.isPhone();
 	const disableCopyToClipboard = tableSettings.disableCopyToClipboard;
 	const templateType = converterContext.getTemplateType();
-	const dataStateIndicatorFilter = templateType === TemplateType.ListReport ? "API.dataStateIndicatorFilter" : undefined;
 	const isCondensedTableLayoutCompliant = checkCondensedLayout && _manifestWrapper.isCondensedLayoutCompliant();
 	const oFilterConfiguration = lineItemAnnotation
 		? getFilterConfiguration(tableSettings, lineItemAnnotation, converterContext, selectionVariantAnnotation)
@@ -4410,6 +4522,7 @@ export function getTableManifestConfiguration(
 	const customValidationFunction = tableSettings.creationMode?.customValidationFunction;
 	const exportRequestSize = tableSettings.exportRequestSize;
 	const tableType = getTableType(converterContext, tableManifestSettings);
+	const analyticalConfiguration = tableSettings.analyticalConfiguration;
 	// By default, paste is enabled on an ObjectPage and on a ListReport with a draft TreeTable
 	const enablePaste =
 		tableSettings.enablePaste ??
@@ -4443,12 +4556,13 @@ export function getTableManifestConfiguration(
 				? getFieldList(tableSettings.creationMode?.creationFields, converterContext)
 				: undefined,
 		customValidationFunction: customValidationFunction,
-		dataStateIndicatorFilter: dataStateIndicatorFilter,
+		hasDataStateIndicatorFilter: templateType === TemplateType.ListReport,
 		// if a custom validation function is provided, disableAddRowButtonForEmptyData should not be considered, i.e. set to false
 		disableAddRowButtonForEmptyData: !customValidationFunction ? !!tableSettings.creationMode?.disableAddRowButtonForEmptyData : false,
 		enableAutoColumnWidth: enableAutoColumnWidth,
 		enablePastingOfComputedProperties: tableSettings.enablePastingOfComputedProperties,
 		enableExport: _getEnableExport(tableSettings, converterContext, enablePaste),
+		analyticalConfiguration,
 		frozenColumnCount: _getFrozenColumnCount(tableSettings),
 		widthIncludingColumnHeader: _getWidthIncludingColumnHeader(tableSettings),
 		enableFullScreen: _getFullScreenBasedOnDevice(tableSettings, converterContext, _manifestWrapper.isPhone()),
@@ -4627,7 +4741,9 @@ function addPropertyToDisplayModeOfDescriptionPropertiesMap(
  */
 function computeHiddenOnRelatedColumns(existingColumns: AnnotationTableColumn[], name: string, column: AnnotationTableColumn): void {
 	const relatedAnnotationColumns = existingColumns.filter(
-		(existingColumn) => existingColumn.propertyInfos?.includes(name) && existingColumn.isPartOfLineItem
+		(existingColumn) =>
+			(existingColumn.propertyInfos?.includes(name) && existingColumn.isPartOfLineItem) ||
+			(existingColumn.isPartOfLineItem && existingColumn.relativePath === column.relativePath)
 	);
 	column.isPartOfLineItem = !!relatedAnnotationColumns.length;
 	if (