@sapui5/sap.fe.core 1.97.0 → 1.99.1

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

@@ -12,7 +12,6 @@ import {
 	LineItem,
 	PathAnnotationExpression,
 	PresentationVariantTypeTypes,
-	PropertyAnnotationValue,
 	PropertyPath,
 	SelectionVariantType,
 	SelectOptionType,
@@ -30,12 +29,13 @@ import {
 	SelectionMode,
 	TableColumnSettings,
 	TableManifestConfiguration,
+	TableManifestSettingsConfiguration,
 	TemplateType,
 	VariantManagementType,
 	ViewPathConfiguration,
 	VisualizationType
 } from "../../ManifestSettings";
-import { EntityType, Property } from "@sap-ux/annotation-converter";
+import { EntityType, Property, TypeDefinition } from "@sap-ux/annotation-converter";
 import { TableID } from "../../helpers/ID";
 import {
 	AnnotationAction,
@@ -69,13 +69,12 @@ import {
 	ExpressionOrPrimitive,
 	formatResult,
 	ifElse,
-	isBinding,
 	isConstant,
 	not,
 	or,
 	resolveBindingString
 } from "sap/fe/core/helpers/BindingExpression";
-import { Draft, bindingContextPathVisitor, singletonPathVisitor, UI } from "sap/fe/core/converters/helpers/BindingHelper";
+import { Entity, bindingContextPathVisitor, UI } from "sap/fe/core/converters/helpers/BindingHelper";
 import { KeyHelper } from "sap/fe/core/converters/helpers/Key";
 import tableFormatters from "sap/fe/core/formatters/TableFormatter";
 import { MessageType } from "sap/fe/core/formatters/TableFormatterTypes";
@@ -84,11 +83,10 @@ import {
 	getTargetObjectPath,
 	isPathDeletable,
 	isPathSearchable,
-	isPathInsertable,
 	isPathUpdatable
 } from "sap/fe/core/templating/DataModelPathHelper";
 import { replaceSpecialChars } from "sap/fe/core/helpers/StableIdHelper";
-import { IssueCategory, IssueSeverity, IssueType } from "sap/fe/core/converters/helpers/IssueManager";
+import { IssueCategory, IssueSeverity, IssueType, IssueCategoryType } from "sap/fe/core/converters/helpers/IssueManager";
 
 import ManifestWrapper from "../../ManifestWrapper";
 import ConverterContext from "../../ConverterContext";
@@ -100,10 +98,26 @@ import {
 	getTargetValueOnDataPoint
 } from "sap/fe/core/templating/PropertyHelper";
 import { AggregationHelper } from "../../helpers/Aggregation";
-import { DisplayMode, getDisplayMode, getTypeConfig } from "sap/fe/core/templating/UIFormatters";
+import { DisplayMode, EDM_TYPE_MAPPING, getDisplayMode } from "sap/fe/core/templating/DisplayModeFormatter";
 import { getMessageTypeFromCriticalityType } from "./Criticality";
 import { FilterFunctions } from "@sap-ux/vocabularies-types/dist/generated/Capabilities";
 import { getNonSortablePropertiesRestrictions } from "sap/fe/core/templating/EntitySetHelper";
+import {
+	generateStandardActionsContext,
+	isExternalCreateConfigured,
+	StandardActionConfigType,
+	getDeleteVisibility,
+	getStandardActionCreate,
+	getStandardActionDelete,
+	getStandardActionPaste,
+	getStandardActionMassEdit,
+	isDraftOrStickySupported,
+	getInsertUpdateActionsTemplating,
+	getCreateVisibility,
+	isInDisplayMode,
+	getMassEditVisibility,
+	getRestrictions
+} from "./table/StandardActions";
 
 export type TableAnnotationConfiguration = {
 	autoBindOnInit: boolean;
@@ -120,11 +134,10 @@ export type TableAnnotationConfiguration = {
 		rowNavigated: BindingExpression<boolean>;
 	};
 	selectionMode: string | undefined;
-	show?: {
-		create?: string | boolean;
-		delete?: string | boolean;
-		paste?: BindingExpression<boolean>;
-		massEdit?: { visible: boolean | string; enabled: boolean | string };
+	standardActions: {
+		actions: Record<string, StandardActionConfigType>;
+		isInsertUpdateTemplated: boolean;
+		updatablePropertyPath: string;
 	};
 	displayMode?: boolean;
 	threshold: number;
@@ -135,7 +148,6 @@ export type TableAnnotationConfiguration = {
 
 	/** Create new entries */
 	create: CreateBehaviour | CreateBehaviourExternal;
-	parentEntityDeleteEnabled?: BindingExpression<boolean>;
 	title: string;
 	searchable: boolean;
 };
@@ -198,6 +210,7 @@ export type TableControlConfiguration = {
 	showRowCount: boolean;
 	enableMassEdit: boolean | undefined;
 	enableAutoColumnWidth: boolean;
+	dataStateIndicatorFilter: string | undefined;
 };
 
 export type TableType = "GridTable" | "ResponsiveTable" | "AnalyticalTable";
@@ -233,6 +246,7 @@ export type AnnotationTableColumn = BaseTableColumn & {
 	annotationPath: string;
 	relativePath: string;
 	label?: string;
+	tooltip?: string;
 	groupLabel?: string;
 	group?: string;
 	isGroupable?: boolean;
@@ -240,6 +254,7 @@ export type AnnotationTableColumn = BaseTableColumn & {
 	showDataFieldsLabel?: boolean;
 	isKey?: boolean;
 	unit?: string;
+	unitText?: string;
 	exportSettings?: {
 		template?: string;
 		label?: string;
@@ -298,7 +313,7 @@ export type TableVisualization = {
 	actions: BaseAction[];
 	aggregates?: Record<string, AggregateData>;
 	enableAnalytics?: boolean;
-	enableDataStateFilter: boolean;
+	enableAnalyticsSearch?: boolean;
 	operationAvailableMap: string;
 	operationAvailableProperties: string;
 };
@@ -490,6 +505,10 @@ function updateTableVisualizationForAnalytics(
 			tableVisualization.enableAnalytics = true;
 			tableVisualization.aggregates = aggregatesDefinitions;
 
+			const aggregationHelper = new AggregationHelper(entityType, converterContext);
+			const allowedTransformations = aggregationHelper.getAllowedTransformations();
+			tableVisualization.enableAnalyticsSearch = allowedTransformations ? allowedTransformations.indexOf("search") >= 0 : true;
+
 			// Add group and sort conditions from the presentation variant
 			tableVisualization.annotation.groupConditions = getGroupConditions(presentationVariantAnnotation, tableVisualization.columns);
 			tableVisualization.annotation.aggregateConditions = getAggregateConditions(
@@ -545,13 +564,17 @@ export function updateLinkedProperties(entityType: EntityType, tableColumns: Tab
 	tableColumns.forEach(oColumn => {
 		const oTableColumn = oColumn as AnnotationTableColumn;
 		if (oTableColumn.propertyInfos === undefined && oTableColumn.relativePath) {
-			const oProperty = entityType.entityProperties.find(oProp => oProp.name === oTableColumn.relativePath);
+			const oProperty = entityType.entityProperties.find((oProp: Property) => oProp.name === oTableColumn.relativePath);
 			if (oProperty) {
-				const sUnit = getAssociatedCurrencyProperty(oProperty)?.name || getAssociatedUnitProperty(oProperty)?.name;
-				if (sUnit) {
-					const oUnitColumn = findColumnByPath(sUnit);
-
+				const oUnit = getAssociatedCurrencyProperty(oProperty) || getAssociatedUnitProperty(oProperty);
+				if (oUnit) {
+					const oUnitColumn = findColumnByPath(oUnit.name);
 					oTableColumn.unit = oUnitColumn?.name;
+				} else {
+					const sUnit = oProperty?.annotations?.Measures?.ISOCurrency || oProperty?.annotations?.Measures?.Unit;
+					if (sUnit) {
+						oTableColumn.unitText = `${sUnit}`;
+					}
 				}
 
 				const displayMode = getDisplayMode(oProperty),
@@ -604,7 +627,6 @@ export function createTableVisualization(
 		control: tableManifestConfig,
 		actions: removeDuplicateActions(getTableActions(lineItemAnnotation, visualizationPath, converterContext, navigationSettings)),
 		columns: columns,
-		enableDataStateFilter: converterContext.getTemplateType() === "ObjectPage",
 		operationAvailableMap: JSON.stringify(operationAvailableMap),
 		operationAvailableProperties: getOperationAvailableProperties(operationAvailableMap, converterContext)
 	};
@@ -630,7 +652,6 @@ export function createDefaultTableVisualization(converterContext: ConverterConte
 		control: tableManifestConfig,
 		actions: [],
 		columns: columns,
-		enableDataStateFilter: converterContext.getTemplateType() === "ObjectPage",
 		operationAvailableMap: JSON.stringify(operationAvailableMap),
 		operationAvailableProperties: getOperationAvailableProperties(operationAvailableMap, converterContext)
 	};
@@ -688,6 +709,22 @@ function getOperationAvailableMap(lineItemAnnotation: LineItem | undefined, conv
 	return operationAvailableMap;
 }
 
+/**
+ * Gets updatable propertyPath for the current entityset if valid.
+ *
+ * @param converterContext The instance of the converter context
+ * @returns {string} The updatable property for the rows
+ */
+function getCurrentEntitySetUpdatablePath(converterContext: ConverterContext): string {
+	const restrictions = getRestrictions(converterContext);
+	const entitySet = converterContext.getEntitySet();
+	const updatable = restrictions.isUpdatable;
+	const isOnlyDynamicOnCurrentEntity: any = updatable.isOnlyCurrentEntityExpression && !isConstant(updatable.expression);
+	const updatablePropertyPath = (entitySet?.annotations.Capabilities?.UpdateRestrictions?.Updatable as any)?.path;
+
+	return isOnlyDynamicOnCurrentEntity ? (updatablePropertyPath as string) : "";
+}
+
 /**
  * Method to retrieve all property paths assigned to the Core.OperationAvailable annotation.
  *
@@ -910,7 +947,8 @@ export function getSelectionMode(
 	converterContext: ConverterContext,
 	isEntitySet: boolean,
 	targetCapabilities: TableCapabilityRestriction,
-	isDeleteButtonVisible?: Expression<boolean>
+	deleteButtonVisibilityExpression?: Expression<boolean>,
+	massEditVisibilityExpression: Expression<boolean> = constant(false)
 ): string | undefined {
 	if (!lineItemAnnotation) {
 		return SelectionMode.None;
@@ -931,12 +969,31 @@ export function getSelectionMode(
 		isParentDeletable = isPathDeletable(converterContext.getDataModelObjectPath(), undefined);
 		parentEntitySetDeletable = isParentDeletable ? compileBinding(isParentDeletable, true) : isParentDeletable;
 	}
-	if (selectionMode && selectionMode === SelectionMode.None && isDeleteButtonVisible) {
-		return compileBinding(ifElse(isDeleteButtonVisible, constant("Multi"), constant("None")));
+
+	const bMassEditEnabled: boolean = !isConstant(massEditVisibilityExpression) || massEditVisibilityExpression.value !== false;
+	if (selectionMode && selectionMode === SelectionMode.None && deleteButtonVisibilityExpression) {
+		if (converterContext.getTemplateType() === TemplateType.ObjectPage && bMassEditEnabled) {
+			// Mass Edit in OP is enabled only in edit mode.
+			return compileBinding(
+				ifElse(
+					and(equal(bindingExpression("/editMode", "ui"), "Editable"), massEditVisibilityExpression),
+					constant("Multi"),
+					ifElse(deleteButtonVisibilityExpression, constant("Multi"), constant("None"))
+				)
+			);
+		} else if (bMassEditEnabled) {
+			return SelectionMode.Multi;
+		}
+
+		return compileBinding(ifElse(deleteButtonVisibilityExpression, constant("Multi"), constant("None")));
 	}
 	if (!selectionMode || selectionMode === SelectionMode.Auto) {
 		selectionMode = SelectionMode.Multi;
 	}
+	if (bMassEditEnabled) {
+		// Override default selection mode when mass edit is visible
+		selectionMode = selectionMode === SelectionMode.Single ? SelectionMode.Single : SelectionMode.Multi;
+	}
 
 	if (
 		hasBoundActionsAlwaysVisibleInToolBar(lineItemAnnotation, converterContext.getEntityType()) ||
@@ -953,12 +1010,22 @@ export function getSelectionMode(
 	aVisibleBindingExpressions = getVisibleExpForCustomActionsRequiringContext(manifestActions);
 
 	// No action requiring a context:
-	if (aHiddenBindingExpressions.length === 0 && aVisibleBindingExpressions.length === 0 && isDeleteButtonVisible) {
+	if (
+		aHiddenBindingExpressions.length === 0 &&
+		aVisibleBindingExpressions.length === 0 &&
+		(deleteButtonVisibilityExpression || bMassEditEnabled)
+	) {
 		if (!isEntitySet) {
-			if (targetCapabilities.isDeletable || parentEntitySetDeletable !== "false") {
+			// Example: OP case
+			if (targetCapabilities.isDeletable || parentEntitySetDeletable !== "false" || bMassEditEnabled) {
+				// Building expression for delete and mass edit
+				const buttonVisibilityExpression = or(
+					deleteButtonVisibilityExpression || true, // default delete visibility as true
+					massEditVisibilityExpression
+				);
 				return compileBinding(
 					ifElse(
-						and(equal(bindingExpression("/editMode", "ui"), "Editable"), isDeleteButtonVisible),
+						and(equal(bindingExpression("/editMode", "ui"), "Editable"), buttonVisibilityExpression),
 						constant(selectionMode),
 						constant(SelectionMode.None)
 					)
@@ -967,18 +1034,28 @@ export function getSelectionMode(
 				return SelectionMode.None;
 			}
 			// EntitySet deletable:
-		} else if (targetCapabilities.isDeletable && isDeleteButtonVisible) {
-			return compileBinding(ifElse(isDeleteButtonVisible, constant(selectionMode), constant("None")));
+		} else if (bMassEditEnabled) {
+			// example: LR scenario
+			return selectionMode;
+		} else if (targetCapabilities.isDeletable && deleteButtonVisibilityExpression) {
+			return compileBinding(ifElse(deleteButtonVisibilityExpression, constant(selectionMode), constant("None")));
 			// EntitySet not deletable:
 		} else {
 			return SelectionMode.None;
 		}
 		// There are actions requiring a context:
 	} else if (!isEntitySet) {
-		if (targetCapabilities.isDeletable || parentEntitySetDeletable !== "false") {
+		// Example: OP case
+		if (targetCapabilities.isDeletable || parentEntitySetDeletable !== "false" || bMassEditEnabled) {
+			// Use selectionMode in edit mode if delete is enabled or mass edit is visible
+			const editModebuttonVisibilityExpression = ifElse(
+				bMassEditEnabled && !targetCapabilities.isDeletable,
+				massEditVisibilityExpression,
+				constant(true)
+			);
 			return compileBinding(
 				ifElse(
-					equal(bindingExpression("/editMode", "ui"), "Editable"),
+					and(equal(bindingExpression("/editMode", "ui"), "Editable"), editModebuttonVisibilityExpression),
 					constant(selectionMode),
 					ifElse(
 						or(...aHiddenBindingExpressions.concat(aVisibleBindingExpressions)),
@@ -997,13 +1074,14 @@ export function getSelectionMode(
 			);
 		}
 		//EntitySet deletable:
-	} else if (targetCapabilities.isDeletable) {
-		return SelectionMode.Multi;
+	} else if (targetCapabilities.isDeletable || bMassEditEnabled) {
+		// Example: LR scenario
+		return selectionMode;
 		//EntitySet not deletable:
 	} else {
 		return compileBinding(
 			ifElse(
-				or(...aHiddenBindingExpressions.concat(aVisibleBindingExpressions)),
+				or(...aHiddenBindingExpressions.concat(aVisibleBindingExpressions), massEditVisibilityExpression),
 				constant(selectionMode),
 				constant(SelectionMode.None)
 			)
@@ -1109,14 +1187,25 @@ function getHighlightRowBinding(
 			defaultHighlightRowDefinition = getMessageTypeFromCriticalityType(criticalityAnnotation);
 		}
 	}
-	return ifElse(
-		isDraftRoot && Draft.IsNewObject,
-		MessageType.Information as MessageType,
-		formatResult(
-			[defaultHighlightRowDefinition, bindingExpression(`filteredMessages`, "internal")],
-			tableFormatters.rowHighlighting,
-			targetEntityType
-		)
+
+	const aMissingKeys: any[] = [];
+	targetEntityType?.keys.forEach((key: any) => {
+		if (key.name !== "IsActiveEntity") {
+			aMissingKeys.push(bindingExpression(key.name, undefined));
+		}
+	});
+
+	return formatResult(
+		[
+			defaultHighlightRowDefinition,
+			bindingExpression(`filteredMessages`, "internal"),
+			isDraftRoot && Entity.HasActive,
+			isDraftRoot && Entity.IsActive,
+			`${isDraftRoot}`,
+			...aMissingKeys
+		],
+		tableFormatters.rowHighlighting,
+		targetEntityType
 	);
 }
 
@@ -1129,10 +1218,10 @@ function _getCreationBehaviour(
 	const navigation = navigationSettings?.create || navigationSettings?.detail;
 
 	// cross-app
-	if (navigation?.outbound && navigation.outboundDetail && navigationSettings?.create) {
+	if (isExternalCreateConfigured(navigationSettings) && navigation) {
 		return {
 			mode: "External",
-			outbound: navigation.outbound,
+			outbound: navigation.outbound as string,
 			outboundDetail: navigation.outboundDetail,
 			navigationSettings: navigationSettings
 		};
@@ -1361,7 +1450,8 @@ const getColumnDefinitionFromProperty = function(
 				trueValue: property.type === "Edm.Boolean" ? "Yes" : undefined,
 				falseValue: property.type === "Edm.Boolean" ? "No" : undefined
 		  };
-	return {
+
+	const oColumn: any = {
 		key: key,
 		isGroupable: !isDataPointFakeProperty && !isHidden ? aggregationHelper.isPropertyGroupable(property) : false,
 		type: ColumnType.Annotation,
@@ -1384,7 +1474,13 @@ const getColumnDefinitionFromProperty = function(
 		caseSensitive: isFilteringCaseSensitive(converterContext),
 		typeConfig: oTypeConfig,
 		visualSettings: isDataPointFakeProperty ? { widthCalculation: null } : undefined
-	} as AnnotationTableColumn;
+	};
+	const sTooltip = _getTooltip(property);
+	if (sTooltip) {
+		oColumn.tooltip = sTooltip;
+	}
+
+	return oColumn as AnnotationTableColumn;
 };
 
 /**
@@ -1426,7 +1522,7 @@ const _isValidColumn = function(dataField: DataFieldAbstractTypes) {
 export const _getVisibleExpression = function(
 	dataFieldModelPath: DataModelObjectPath,
 	formatOptions?: any,
-	returnExpression?: Boolean
+	returnExpression: boolean = false
 ): BindingExpression<string> {
 	const targetObject: DataFieldAbstractTypes | DataPointTypeTypes = dataFieldModelPath.targetObject;
 	let propertyValue;
@@ -1479,7 +1575,7 @@ export const _getVisibleExpression = function(
 const _getFieldGroupHiddenExpressions = function(
 	dataFieldGroup: DataFieldAbstractTypes,
 	fieldFormatOptions: any
-): BindingExpression<string> {
+): BindingExpression<string> | undefined {
 	const aFieldGroupHiddenExpressions: BindingExpression<string>[] = [];
 	if (
 		dataFieldGroup.$Type === UIAnnotationTypes.DataFieldForAnnotation &&
@@ -1493,6 +1589,8 @@ const _getFieldGroupHiddenExpressions = function(
 		return compileBinding(
 			ifElse(or(...(aFieldGroupHiddenExpressions as ExpressionOrPrimitive<boolean>[])), constant(true), constant(false))
 		);
+	} else {
+		return undefined;
 	}
 };
 
@@ -1533,6 +1631,29 @@ const _getLabel = function(property: DataFieldAbstractTypes | Property, isGroup:
 	}
 };
 
+const _getTooltip = function(source: DataFieldAbstractTypes | Property): string | undefined {
+	if (!source) {
+		return undefined;
+	}
+
+	if (isProperty(source)) {
+		return source.annotations.Common?.QuickInfo
+			? compileBinding(annotationExpression(source.annotations.Common.QuickInfo.valueOf()))
+			: undefined;
+	} else if (isDataFieldTypes(source)) {
+		return source.Value?.$target?.annotations?.Common?.QuickInfo
+			? compileBinding(annotationExpression(source.Value.$target.annotations.Common.QuickInfo.valueOf()))
+			: undefined;
+	} else if (source.$Type === UIAnnotationTypes.DataFieldForAnnotation) {
+		const datapointTarget = source.Target?.$target as DataPoint;
+		return datapointTarget?.Value?.$target?.annotations?.Common?.QuickInfo
+			? compileBinding(annotationExpression(datapointTarget.Value.$target.annotations.Common.QuickInfo.valueOf()))
+			: undefined;
+	} else {
+		return undefined;
+	}
+};
+
 /**
  * Creates a PropertyInfo for each identified property consumed by a LineItem.
  *
@@ -1797,7 +1918,6 @@ const getColumnsFromAnnotations = function(
 		converterContext.getEntityType()
 	])[0];
 	if (lineItemAnnotation) {
-		// Get columns from the LineItem Annotation
 		lineItemAnnotation.forEach(lineItem => {
 			if (!_isValidColumn(lineItem)) {
 				return;
@@ -1816,10 +1936,9 @@ const getColumnsFromAnnotations = function(
 			const sLabel: string | undefined = _getLabel(lineItem, isGroup);
 			const name = _getAnnotationColumnName(lineItem);
 			const isFieldGroupColumn: boolean = groupPath.indexOf("@com.sap.vocabularies.UI.v1.FieldGroup") > -1;
-			const showDataFieldsLabel: boolean =
-				isFieldGroupColumn && (lineItem as any)?.Target?.$target?.Data.length > 1
-					? _getShowDataFieldsLabel(name, visualizationPath, converterContext)
-					: false;
+			const showDataFieldsLabel: boolean = isFieldGroupColumn
+				? _getShowDataFieldsLabel(name, visualizationPath, converterContext)
+				: false;
 			const dataType: string | undefined = getDataFieldDataType(lineItem);
 			const sDateInputFormat: string | undefined = dataType === "Edm.Date" ? "YYYY-MM-DD" : undefined;
 			const formatOptions = {
@@ -1866,7 +1985,19 @@ const getColumnsFromAnnotations = function(
 				visualSettings.widthCalculation = null;
 			}
 
-			annotationColumns.push({
+			// TODO: For situation POC - increase width of the column with the situations indicator - works for the situations demo app only!
+			// Might be a good idea to move the complete column width determination to the converter, that would allow us to widen
+			// the columns as needed. This workaround only deals with Date columns.
+			const { hasDraftIndicator } = getDefaultDraftIndicatorForColumn(name, semanticKeys);
+			const widthOverride =
+				(converterContext.getEntityType().annotations as any).FE?.Situations &&
+				hasDraftIndicator &&
+				lineItem.$Type === UIAnnotationTypes.DataField &&
+				lineItem.Value.$target.type === "Edm.Date"
+					? "11em"
+					: undefined;
+
+			const oColumn: any = {
 				key: KeyHelper.generateKeyFromDataField(lineItem),
 				type: ColumnType.Annotation,
 				label: sLabel,
@@ -1883,14 +2014,20 @@ const getColumnsFromAnnotations = function(
 				propertyInfos: relatedPropertyNames.length > 0 ? relatedPropertyNames : undefined,
 				additionalPropertyInfos: additionalPropertyNames.length > 0 ? additionalPropertyNames : undefined,
 				exportSettings: exportSettings,
-				width: lineItem.annotations?.HTML5?.CssDefaults?.width || undefined,
+				width: lineItem.annotations?.HTML5?.CssDefaults?.width || widthOverride || undefined,
 				isNavigable: true,
 				formatOptions: formatOptions,
 				exportContactProperty: relatedPropertiesInfo.exportSettingsContactProperty,
 				caseSensitive: isFilteringCaseSensitive(converterContext),
 				typeConfig: oTypeConfig,
 				visualSettings: visualSettings
-			} as AnnotationTableColumn);
+			};
+			const sTooltip = _getTooltip(lineItem);
+			if (sTooltip) {
+				oColumn.tooltip = sTooltip;
+			}
+
+			annotationColumns.push(oColumn as AnnotationTableColumn);
 
 			// Collect information of related columns to be created.
 			relatedPropertyNames.forEach(name => {
@@ -2021,36 +2158,48 @@ const getColumnsFromManifest = function(
 			converterContext,
 			entityType
 		);
-
-		internalColumns[key] = {
-			key: key,
-			id: "CustomColumn::" + key,
-			name: "CustomColumn::" + key,
-			header: manifestColumn.header,
-			width: manifestColumn.width || undefined,
-			horizontalAlign: _getManifestOrDefaultValue(manifestColumn?.horizontalAlign, HorizontalAlign.Begin, isAnnotationColumn),
-			type: manifestColumn.type === "Slot" ? ColumnType.Slot : ColumnType.Default,
-			availability: _getManifestOrDefaultValue(manifestColumn?.availability, AvailabilityType.Default, isAnnotationColumn),
-			template: manifestColumn.template || "undefined",
-			position: {
-				anchor: manifestColumn.position?.anchor,
-				placement: manifestColumn.position === undefined ? Placement.After : manifestColumn.position.placement
-			},
-			isNavigable: isAnnotationColumn ? undefined : isActionNavigable(manifestColumn, navigationSettings, true),
-			settings: manifestColumn.settings,
-			sortable: false,
-			propertyInfos: propertyInfos,
-			formatOptions: {
-				...getDefaultFormatOptionsForTable(),
-				...manifestColumn.formatOptions
-			},
-			exportSettings: {
-				template: propertyInfos ? _appendCustomTemplate(propertyInfos) : undefined,
-				fieldLabel: propertyInfos ? manifestColumn.header : undefined,
-				wrap: propertyInfos && propertyInfos.length > 1 ? true : false
-			},
-			caseSensitive: isFilteringCaseSensitive(converterContext)
-		};
+		if (!manifestColumn?.template && !isAnnotationColumn) {
+			const Message = "The annotation column '" + key + "' referenced in the manifest is not found";
+			converterContext
+				.getDiagnostics()
+				.addIssue(
+					IssueCategory.Manifest,
+					IssueSeverity.Low,
+					Message,
+					IssueCategoryType,
+					IssueCategoryType?.AnnotationColumns?.InvalidKey
+				);
+		} else {
+			internalColumns[key] = {
+				key: key,
+				id: "CustomColumn::" + key,
+				name: "CustomColumn::" + key,
+				header: manifestColumn.header,
+				width: manifestColumn.width || undefined,
+				horizontalAlign: _getManifestOrDefaultValue(manifestColumn?.horizontalAlign, HorizontalAlign.Begin, isAnnotationColumn),
+				type: manifestColumn.type === "Slot" ? ColumnType.Slot : ColumnType.Default,
+				availability: _getManifestOrDefaultValue(manifestColumn?.availability, AvailabilityType.Default, isAnnotationColumn),
+				template: manifestColumn.template || "undefined",
+				position: {
+					anchor: manifestColumn.position?.anchor,
+					placement: manifestColumn.position === undefined ? Placement.After : manifestColumn.position.placement
+				},
+				isNavigable: isAnnotationColumn ? undefined : isActionNavigable(manifestColumn, navigationSettings, true),
+				settings: manifestColumn.settings,
+				sortable: false,
+				propertyInfos: propertyInfos,
+				formatOptions: {
+					...getDefaultFormatOptionsForTable(),
+					...manifestColumn.formatOptions
+				},
+				exportSettings: {
+					template: propertyInfos ? _appendCustomTemplate(propertyInfos) : undefined,
+					fieldLabel: propertyInfos ? manifestColumn.header : undefined,
+					wrap: propertyInfos && propertyInfos.length > 1 ? true : false
+				},
+				caseSensitive: isFilteringCaseSensitive(converterContext)
+			};
+		}
 	}
 	return internalColumns;
 };
@@ -2094,9 +2243,10 @@ export function getP13nMode(
 		// No personalization configured in manifest.
 		aPersonalization.push("Sort");
 		aPersonalization.push("Column");
-		if (variantManagement === VariantManagementType.Control) {
+		if (variantManagement === VariantManagementType.Control || _isFilterBarHidden(manifestWrapper, converterContext)) {
 			// Feature parity with V2.
 			// Enable table filtering by default only in case of Control level variant management.
+			// Or when the LR filter bar is hidden via manifest setting
 			aPersonalization.push("Filter");
 		}
 		if (bAnalyticalTable) {
@@ -2109,256 +2259,20 @@ export function getP13nMode(
 }
 
 /**
- * Function to determine the visibility of the Delete button.
- *
- * @param converterContext The instance of the converter context
- * @param navigationPath Path to the navigation entity
- * @param isTargetDeletable Flag which determines whether a target is deletable
- * @param viewConfiguration The instance of the configuration for the view path
- * @returns {Expression<boolean>} The expression for the Delete button
- */
-export function getDeleteVisible(
-	converterContext: ConverterContext,
-	navigationPath: string,
-	isTargetDeletable: boolean,
-	viewConfiguration?: ViewPathConfiguration
-): Expression<boolean> {
-	const currentEntitySet = converterContext.getEntitySet();
-	const dataModelObjectPath = converterContext.getDataModelObjectPath();
-	const visitedNavigationPaths = dataModelObjectPath.navigationProperties.map(navProp => navProp.name);
-	const isDeleteHiddenExpression = currentEntitySet
-		? annotationExpression(
-				(currentEntitySet?.annotations.UI?.DeleteHidden as PropertyAnnotationValue<boolean>) || false,
-				visitedNavigationPaths,
-				undefined,
-				(path: string) => singletonPathVisitor(path, converterContext, visitedNavigationPaths)
-		  )
-		: constant(false);
-	const isDeleteHidden: any = compileBinding(isDeleteHiddenExpression);
-	let isParentDeletable, parentEntitySetDeletable;
-	if (converterContext.getTemplateType() === TemplateType.ObjectPage) {
-		isParentDeletable = isPathDeletable(converterContext.getDataModelObjectPath(), navigationPath);
-		parentEntitySetDeletable = isParentDeletable ? compileBinding(isParentDeletable) : isParentDeletable;
-	}
-	const bIsStickySessionSupported = converterContext.getDataModelObjectPath().startingEntitySet?.annotations?.Session
-		?.StickySessionSupported
-		? true
-		: false;
-	const bIsDraftRoot = currentEntitySet && currentEntitySet.annotations?.Common?.DraftRoot ? true : false;
-	const bIsDraftNode = currentEntitySet && currentEntitySet.annotations?.Common?.DraftNode ? true : false;
-	const bIsDraftParentEntityForContainment =
-		converterContext.getDataModelObjectPath().targetObject?.containsTarget &&
-		(converterContext.getDataModelObjectPath().startingEntitySet?.annotations?.Common?.DraftRoot ||
-			converterContext.getDataModelObjectPath().startingEntitySet?.annotations?.Common?.DraftNode)
-			? true
-			: false;
-	if (
-		bIsDraftRoot ||
-		bIsDraftNode ||
-		bIsStickySessionSupported ||
-		(!converterContext.getEntitySet() && bIsDraftParentEntityForContainment)
-	) {
-		//do not show case the delete button if parentEntitySetDeletable is false
-		if (parentEntitySetDeletable === "false") {
-			return constant(false);
-			//OP
-		} else if (parentEntitySetDeletable && isDeleteHidden !== "true") {
-			//Delete Hidden in case of true and path based
-			if (isDeleteHidden && isDeleteHidden !== "false") {
-				return and(equal(bindingExpression("/editMode", "ui"), "Editable"), not(isDeleteHiddenExpression));
-			} else {
-				return equal(bindingExpression("/editMode", "ui"), "Editable");
-			}
-		} else if (
-			isDeleteHidden === "true" ||
-			!isTargetDeletable ||
-			(viewConfiguration && converterContext.getManifestWrapper().hasMultipleVisualizations(viewConfiguration)) ||
-			converterContext.getTemplateType() === TemplateType.AnalyticalListPage
-		) {
-			return constant(false);
-		} else if (converterContext.getTemplateType() !== TemplateType.ListReport) {
-			if (isDeleteHidden && isDeleteHidden === "false") {
-				return and(equal(bindingExpression("/editMode", "ui"), "Editable"), not(isDeleteHiddenExpression));
-			} else {
-				return equal(bindingExpression("/editMode", "ui"), "Editable");
-			}
-		} else if (isBinding(isDeleteHiddenExpression)) {
-			// UI.DeleteHidden annotation points to a path
-			return not(isDeleteHiddenExpression);
-		} else {
-			return constant(true);
-		}
-	} else {
-		return constant(false);
-	}
-}
-
-/**
- * Returns the enablement for the 'Mass Edit' button
- *
- * @param converterContext The converterContext
- * @param bMassEditVisible The visibility of the 'Mass Edit' button
- * @returns {*} Expression or Boolean value for the enablement of the 'Mass Edit' button
- */
-
-export function getEnablementMassEdit(
-	converterContext: ConverterContext,
-	bMassEditVisible: string | boolean | undefined
-): string | boolean {
-	if (bMassEditVisible) {
-		const isParentUpdatable: any = isPathUpdatable(converterContext.getDataModelObjectPath(), undefined, true);
-		//when updatable is path based and pointing to current entity set property, that case is handled in table helper and runtime
-		if (isParentUpdatable?.currentEntityRestriction) {
-			return false;
-		}
-		const oExpression: any = compileBinding(isParentUpdatable);
-		return isParentUpdatable
-			? "{= %{internal>numberOfSelectedContexts} >= 2 && " + compileBinding(isParentUpdatable, oExpression) + "}"
-			: false;
-	}
-	return false;
-}
-
-/**
- * Returns the visibility for the 'Mass Edit' button
+ * Returns a boolean suggesting if a filter bar is being used on the page.
  *
- * @param converterContext The converterContext
- * @param tableManifestConfiguration The manifest configuration for the table
- * @param targetCapabilities The target capability restrictions for the table
- * @param selectionMode The selection mode for the table
- * @returns {*} Expression or Boolean value for the visibility of the 'Mass Edit' button
- */
-
-export function getVisibilityMassEdit(
-	converterContext: ConverterContext,
-	tableManifestConfiguration: TableControlConfiguration,
-	targetCapabilities: TableCapabilityRestriction,
-	selectionMode: string | undefined
-): boolean | string | undefined {
-	const entitySet = converterContext.getEntitySet(),
-		bUpdateHidden: any = entitySet && entitySet?.annotations.UI?.UpdateHidden?.valueOf(),
-		bMassEditEnabled: boolean = tableManifestConfiguration?.enableMassEdit || false,
-		iSelectionLimit: number = tableManifestConfiguration?.selectionLimit;
-	let bMassEditVisible: boolean = true;
-	if ((selectionMode && selectionMode === "Single") || (iSelectionLimit && iSelectionLimit < 2)) {
-		bMassEditVisible = false;
-	} else if (selectionMode && (selectionMode === "Auto" || selectionMode === "None")) {
-		bMassEditVisible = true;
-	}
-	if (targetCapabilities?.isUpdatable !== false && bMassEditVisible && bMassEditEnabled) {
-		if (bUpdateHidden && typeof bUpdateHidden === "boolean") {
-			return !bUpdateHidden && converterContext.getTemplateType() === TemplateType.ObjectPage ? compileBinding(UI.IsEditable) : false;
-		} else if (bUpdateHidden && bUpdateHidden?.path) {
-			return converterContext.getTemplateType() === TemplateType.ObjectPage
-				? compileBinding(and(equal(UI.IsEditable, true), equal(annotationExpression(bUpdateHidden), false)))
-				: false;
-		}
-		return converterContext.getTemplateType() === TemplateType.ObjectPage ? compileBinding(UI.IsEditable) : false;
-	}
-	return false;
-}
-
-/**
- * Function to determine the visibility of the Create button.
+ * Chart has a dependency to filter bar (issue with loading data). Once resolved, the check for chart should be removed here.
+ * Until then, hiding filter bar is now allowed if a chart is being used on LR.
  *
- * @param converterContext The instance of the converter context
- * @param creationMode The mode used for creation
- * @param isInsertable Annotation expression of InsertRestrictions.Insertable
- * @param viewConfiguration The instance of the configuration for the view path
- * @returns {Expression<boolean>} Expression or Boolean value of the 'UI.CreateHidden' annotation
- */
-export function getCreateVisible(
-	converterContext: ConverterContext,
-	creationMode: CreationMode | "External",
-	isInsertable: Expression<boolean>,
-	viewConfiguration?: ViewPathConfiguration
-): Expression<boolean> {
-	const currentEntitySet = converterContext.getEntitySet();
-	const dataModelObjectPath = converterContext.getDataModelObjectPath();
-	const visitedNavigationPaths = dataModelObjectPath.navigationProperties.map(navProp => navProp.name);
-	const isCreateHidden: Expression<boolean> = currentEntitySet
-		? annotationExpression(
-				(currentEntitySet?.annotations.UI?.CreateHidden as PropertyAnnotationValue<boolean>) || false,
-				visitedNavigationPaths,
-				undefined,
-				(path: string) => singletonPathVisitor(path, converterContext, visitedNavigationPaths)
-		  )
-		: constant(false);
-
-	// if there is a custom new action the create button will be bound against this new action (instead of a POST action).
-	// The visibility of the create button then depends on the new action's OperationAvailable annotation (instead of the insertRestrictions):
-	// OperationAvailable = true or undefined -> create is visible
-	// OperationAvailable = false -> create is not visible
-	const newActionName: BindingExpression<string> = currentEntitySet?.annotations.Common?.DraftRoot?.NewAction?.toString();
-	const showCreateForNewAction = newActionName
-		? annotationExpression(
-				converterContext?.getEntityType().actions[newActionName].annotations?.Core?.OperationAvailable?.valueOf(),
-				[],
-				true,
-				(path: string) => singletonPathVisitor(path, converterContext, [])
-		  )
-		: undefined;
-	// - If it's statically not insertable -> create is not visible
-	// - If create is statically hidden -> create is not visible
-	// - If it's an ALP template -> create is not visible
-	// -
-	// - Otherwise
-	// 	 - If the create mode is external -> create is visible
-	// 	 - If we're on the list report ->
-	// 	 	- If UI.CreateHidden points to a property path -> provide a negated binding to this path
-	// 	 	- Otherwise, create is visible
-	// 	 - Otherwise
-	// 	   - This depends on the value of the the UI.IsEditable
-	return ifElse(
-		or(
-			or(
-				equal(showCreateForNewAction, false),
-				and(isConstant(isInsertable), equal(isInsertable, false), equal(showCreateForNewAction, undefined))
-			),
-			isConstant(isCreateHidden) && equal(isCreateHidden, true),
-			or(
-				viewConfiguration ? converterContext.getManifestWrapper().hasMultipleVisualizations(viewConfiguration) : false,
-				converterContext.getTemplateType() === TemplateType.AnalyticalListPage
-			)
-		),
-		false,
-		ifElse(
-			creationMode === "External",
-			true,
-			ifElse(
-				converterContext.getTemplateType() === TemplateType.ListReport,
-				ifElse(isBinding(isCreateHidden), not(isCreateHidden), true),
-				and(not(isCreateHidden), UI.IsEditable)
-			)
-		)
-	);
-}
-
-/**
- * Returns the visibility for the Paste button.
- *
- * @param converterContext The instance of the converter context
- * @param creationBehaviour The chosen behavior of creation
- * @param isInsertable The expression which denotes insert restrictions
- * @param pasteEnabledInManifest The flag which denotes the paste enablement status via manifest
- * @param viewConfiguration The instance of the configuration for the view path
- * @returns {Expression<boolean>} Expression or Boolean value of the UI.CreateHidden annotation
+ * @param {ManifestWrapper} manifestWrapper Manifest settings getter for the page
+ * @param {ConverterContext} converterContext The instance of the converter context
+ * @returns {boolean} Boolean suggesting if a filter bar is being used on the page.
  */
-export function getPasteEnabled(
-	converterContext: ConverterContext,
-	creationBehaviour: TableAnnotationConfiguration["create"],
-	isInsertable: Expression<boolean>,
-	pasteEnabledInManifest: boolean,
-	viewConfiguration?: ViewPathConfiguration
-): Expression<boolean> {
-	// If create is not visible -> it's not enabled
-	// If create is visible ->
-	// 	 If it's in the ListReport -> not enabled
-	//	 If it's insertable -> enabled
-	return ifElse(
-		pasteEnabledInManifest && equal(getCreateVisible(converterContext, creationBehaviour.mode, isInsertable, viewConfiguration), true),
-		converterContext.getTemplateType() === TemplateType.ObjectPage && isInsertable,
-		false
+function _isFilterBarHidden(manifestWrapper: ManifestWrapper, converterContext: ConverterContext): boolean {
+	return (
+		manifestWrapper.isFilterBarHidden() &&
+		!converterContext.getManifestWrapper().hasMultipleVisualizations() &&
+		converterContext.getTemplateType() !== TemplateType.AnalyticalListPage
 	);
 }
 
@@ -2491,41 +2405,47 @@ export function getTableAnnotationConfiguration(
 		p13nMode: string | undefined = getP13nMode(visualizationPath, converterContext, tableManifestConfiguration),
 		id = navigationPropertyPath ? TableID(visualizationPath) : TableID(converterContext.getContextPath(), "LineItem");
 	const targetCapabilities = getCapabilityRestriction(converterContext);
-	const isDeleteButtonVisible = getDeleteVisible(
+	const navigationTargetPath = getNavigationTargetPath(converterContext, navigationPropertyPath);
+	const navigationSettings = pageManifestSettings.getNavigationConfiguration(navigationTargetPath);
+	const standardActionsContext = generateStandardActionsContext(
 		converterContext,
-		navigationPropertyPath,
-		targetCapabilities.isDeletable,
+		navigationSettings,
+		tableManifestConfiguration,
 		viewConfiguration
 	);
+
+	const deleteButtonVisibilityExpression = getDeleteVisibility(converterContext, standardActionsContext);
+	const createButtonVisibilityExpression = getCreateVisibility(converterContext, standardActionsContext);
+	const massEditButtonVisibilityExpression = getMassEditVisibility(converterContext, standardActionsContext);
+	const isInsertUpdateTemplated = getInsertUpdateActionsTemplating(
+		standardActionsContext,
+		isDraftOrStickySupported(converterContext),
+		compileBinding(createButtonVisibilityExpression) === "false"
+	);
+
 	const selectionMode = getSelectionMode(
 		lineItemAnnotation,
 		visualizationPath,
 		converterContext,
 		hasAbsolutePath,
 		targetCapabilities,
-		isDeleteButtonVisible
+		deleteButtonVisibilityExpression,
+		massEditButtonVisibilityExpression
 	);
 	let threshold = navigationPropertyPath ? 10 : 30;
 	if (presentationVariantAnnotation?.MaxItems) {
 		threshold = presentationVariantAnnotation.MaxItems.valueOf() as number;
 	}
-	const navigationTargetPath = getNavigationTargetPath(converterContext, navigationPropertyPath);
-	const navigationSettings = pageManifestSettings.getNavigationConfiguration(navigationTargetPath);
+
 	const creationBehaviour = _getCreationBehaviour(lineItemAnnotation, tableManifestConfiguration, converterContext, navigationSettings);
-	let isParentDeletable: any, parentEntitySetDeletable;
-	if (converterContext.getTemplateType() === TemplateType.ObjectPage) {
-		isParentDeletable = isPathDeletable(converterContext.getDataModelObjectPath(), undefined, true);
-		if (isParentDeletable?.currentEntityRestriction) {
-			parentEntitySetDeletable = undefined;
-		} else {
-			parentEntitySetDeletable = isParentDeletable ? compileBinding(isParentDeletable, true) : isParentDeletable;
-		}
-	}
-	const dataModelObjectPath = converterContext.getDataModelObjectPath();
-	const isInsertable: Expression<boolean> = isPathInsertable(dataModelObjectPath);
 	const variantManagement: VariantManagementType = pageManifestSettings.getVariantManagement();
-	const bMassEditVisible: any = getVisibilityMassEdit(converterContext, tableManifestConfiguration, targetCapabilities, selectionMode);
 	const isSearchable = isPathSearchable(converterContext.getDataModelObjectPath());
+	const standardActions = {
+		create: getStandardActionCreate(converterContext, standardActionsContext),
+		"delete": getStandardActionDelete(converterContext, standardActionsContext),
+		paste: getStandardActionPaste(converterContext, standardActionsContext, isInsertUpdateTemplated),
+		massEdit: getStandardActionMassEdit(converterContext, standardActionsContext)
+	};
 
 	return {
 		id: id,
@@ -2540,34 +2460,22 @@ export function getTableAnnotationConfiguration(
 			navigationTargetPath
 		),
 		p13nMode: p13nMode,
-		show: {
-			"delete": compileBinding(isDeleteButtonVisible),
-			create: compileBinding(getCreateVisible(converterContext, creationBehaviour?.mode, isInsertable)),
-			paste: compileBinding(
-				getPasteEnabled(
-					converterContext,
-					creationBehaviour,
-					isInsertable,
-					tableManifestConfiguration.enablePaste,
-					viewConfiguration
-				)
-			),
-			massEdit: {
-				visible: bMassEditVisible,
-				enabled: getEnablementMassEdit(converterContext, bMassEditVisible)
-			}
+		standardActions: {
+			actions: standardActions,
+			isInsertUpdateTemplated: isInsertUpdateTemplated,
+			updatablePropertyPath: getCurrentEntitySetUpdatablePath(converterContext)
 		},
 		displayMode: isInDisplayMode(converterContext, viewConfiguration),
 		create: creationBehaviour,
 		selectionMode: selectionMode,
 		autoBindOnInit:
-			converterContext.getTemplateType() !== TemplateType.ListReport &&
-			converterContext.getTemplateType() !== TemplateType.AnalyticalListPage &&
-			!(viewConfiguration && converterContext.getManifestWrapper().hasMultipleVisualizations(viewConfiguration)),
+			_isFilterBarHidden(pageManifestSettings, converterContext) ||
+			(converterContext.getTemplateType() !== TemplateType.ListReport &&
+				converterContext.getTemplateType() !== TemplateType.AnalyticalListPage &&
+				!(viewConfiguration && pageManifestSettings.hasMultipleVisualizations(viewConfiguration))),
 		variantManagement: variantManagement === "Control" && !p13nMode ? VariantManagementType.None : variantManagement,
 		threshold: threshold,
 		sortConditions: getSortConditions(converterContext, presentationVariantAnnotation, columns),
-		parentEntityDeleteEnabled: parentEntitySetDeletable,
 		title: title,
 		searchable: tableManifestConfiguration.type !== "AnalyticalTable" && !(isConstant(isSearchable) && isSearchable.value === false)
 	};
@@ -2606,19 +2514,6 @@ function _getExportDataType(dataType: string, isComplexProperty: boolean = false
 	return exportDataType;
 }
 
-function isInDisplayMode(converterContext: ConverterContext, viewConfiguration?: ViewPathConfiguration): boolean {
-	const templateType = converterContext.getTemplateType();
-	if (
-		templateType === TemplateType.ListReport ||
-		templateType === TemplateType.AnalyticalListPage ||
-		(viewConfiguration && converterContext.getManifestWrapper().hasMultipleVisualizations(viewConfiguration))
-	) {
-		return true;
-	}
-	// updatable will be handled at the property level
-	return false;
-}
-
 /**
  * Split the visualization path into the navigation property path and annotation.
  *
@@ -2659,118 +2554,236 @@ export function getSelectionVariantConfiguration(
 	return undefined;
 }
 
+function _getFullScreenBasedOnDevice(
+	tableSettings: TableManifestSettingsConfiguration,
+	converterContext: ConverterContext,
+	isIphone: boolean
+): boolean {
+	// If enableFullScreen is not set, use as default true on phone and false otherwise
+	let enableFullScreen = tableSettings.enableFullScreen ?? isIphone;
+	// Make sure that enableFullScreen is not set on ListReport for desktop or tablet
+	if (!isIphone && enableFullScreen && converterContext.getTemplateType() === TemplateType.ListReport) {
+		enableFullScreen = false;
+		converterContext.getDiagnostics().addIssue(IssueCategory.Manifest, IssueSeverity.Low, IssueType.FULLSCREENMODE_NOT_ON_LISTREPORT);
+	}
+	return enableFullScreen;
+}
+
+function _getMultiSelectMode(
+	tableSettings: TableManifestSettingsConfiguration,
+	tableType: TableType,
+	converterContext: ConverterContext
+): string | undefined {
+	let multiSelectMode: string | undefined;
+	if (tableType !== "ResponsiveTable") {
+		return undefined;
+	}
+	switch (converterContext.getTemplateType()) {
+		case TemplateType.ListReport:
+		case TemplateType.AnalyticalListPage:
+			multiSelectMode = !tableSettings.selectAll ? "ClearAll" : "Default";
+			break;
+		case TemplateType.ObjectPage:
+			multiSelectMode = tableSettings.selectAll === false ? "ClearAll" : "Default";
+			if (converterContext.getManifestWrapper().useIconTabBar()) {
+				multiSelectMode = !tableSettings.selectAll ? "ClearAll" : "Default";
+			}
+			break;
+		default:
+	}
+
+	return multiSelectMode;
+}
+
+function _getTableType(
+	tableSettings: TableManifestSettingsConfiguration,
+	aggregationHelper: AggregationHelper,
+	converterContext: ConverterContext
+): TableType {
+	let tableType = tableSettings?.type || "ResponsiveTable";
+	if (converterContext.getTemplateType() !== "ObjectPage") {
+		if (tableSettings?.type === "AnalyticalTable" && !aggregationHelper.isAnalyticsSupported()) {
+			tableType = "GridTable";
+		}
+		if (!tableSettings?.type) {
+			if (converterContext.getManifestWrapper().isDesktop() && aggregationHelper.isAnalyticsSupported()) {
+				tableType = "AnalyticalTable";
+			} else {
+				tableType = "ResponsiveTable";
+			}
+		}
+	}
+	return tableType;
+}
+function _getFilters(
+	tableSettings: TableManifestSettingsConfiguration,
+	quickFilterPaths: { annotationPath: string }[],
+	quickSelectionVariant: any,
+	path: { annotationPath: string },
+	converterContext: ConverterContext
+): any {
+	if (quickSelectionVariant) {
+		quickFilterPaths.push({ annotationPath: path.annotationPath });
+	}
+	return {
+		quickFilters: {
+			enabled:
+				converterContext.getTemplateType() === TemplateType.ListReport ? "{= ${pageInternal>hasPendingFilters} !== true}" : true,
+			showCounts: tableSettings?.quickVariantSelection?.showCounts,
+			paths: quickFilterPaths
+		}
+	};
+}
+
+function _getEnableExport(
+	tableSettings: TableManifestSettingsConfiguration,
+	converterContext: ConverterContext,
+	enablePaste: boolean
+): boolean {
+	return tableSettings.enableExport !== undefined
+		? tableSettings.enableExport
+		: converterContext.getTemplateType() !== "ObjectPage" || enablePaste;
+}
+
+function _getFilterConfiguration(
+	tableSettings: TableManifestSettingsConfiguration,
+	lineItemAnnotation: LineItem | undefined,
+	converterContext: ConverterContext
+): any {
+	if (!lineItemAnnotation) {
+		return {};
+	}
+	const quickFilterPaths: { annotationPath: string }[] = [];
+	const targetEntityType = converterContext.getAnnotationEntityType(lineItemAnnotation);
+	let quickSelectionVariant: any;
+	let filters;
+	tableSettings?.quickVariantSelection?.paths?.forEach((path: { annotationPath: string }) => {
+		quickSelectionVariant = targetEntityType.resolvePath("@" + path.annotationPath);
+		filters = _getFilters(tableSettings, quickFilterPaths, quickSelectionVariant, path, converterContext);
+	});
+
+	let hideTableTitle = false;
+	hideTableTitle = !!tableSettings.quickVariantSelection?.hideTableTitle;
+	return {
+		filters: filters,
+		headerVisible: !(quickSelectionVariant && hideTableTitle)
+	};
+}
+
 export function getTableManifestConfiguration(
 	lineItemAnnotation: LineItem | undefined,
 	visualizationPath: string,
 	converterContext: ConverterContext,
-	checkCondensedLayout: boolean = false
+	checkCondensedLayout = false
 ): TableControlConfiguration {
 	const tableManifestSettings: TableManifestConfiguration = converterContext.getManifestControlConfiguration(visualizationPath);
 	const tableSettings = (tableManifestSettings && tableManifestSettings.tableSettings) || {};
-	let quickSelectionVariant: any;
-	const quickFilterPaths: { annotationPath: string }[] = [];
-	let enableExport = true;
-	let creationMode = CreationMode.NewPage;
-	let filters;
-	let createAtEnd = true;
-	let disableAddRowButtonForEmptyData = false;
-	let customValidationFunction;
-	let condensedTableLayout = false;
-	let hideTableTitle = false;
-	let tableType: TableType = "ResponsiveTable";
-	let enableFullScreen = false;
-	let selectionLimit = 200;
-	let multiSelectMode;
-	const enableAutoColumnWidth = true;
-	let enablePaste = converterContext.getTemplateType() === "ObjectPage";
+	const creationMode = CreationMode.NewPage;
+	const enableAutoColumnWidth = !converterContext.getManifestWrapper().isPhone();
+	const enablePaste =
+		tableSettings.enablePaste !== undefined ? tableSettings.enablePaste : converterContext.getTemplateType() === "ObjectPage"; // Paste is disabled by default excepted for OP
+	const dataStateIndicatorFilter =
+		converterContext.getTemplateType() === TemplateType.ListReport ? "API.dataStateIndicatorFilter" : undefined;
 	const isCondensedTableLayoutCompliant = checkCondensedLayout && converterContext.getManifestWrapper().isCondensedLayoutCompliant();
+	const oFilterConfiguration = _getFilterConfiguration(tableSettings, lineItemAnnotation, converterContext);
+	const customValidationFunction = tableSettings.creationMode?.customValidationFunction;
+	const condensedTableLayout = tableSettings.condensedTableLayout !== undefined ? tableSettings.condensedTableLayout : false;
 	const entityType = converterContext.getEntityType();
 	const aggregationHelper = new AggregationHelper(entityType, converterContext);
-	if (lineItemAnnotation) {
-		const targetEntityType = converterContext.getAnnotationEntityType(lineItemAnnotation);
-		tableSettings?.quickVariantSelection?.paths?.forEach((path: { annotationPath: string }) => {
-			quickSelectionVariant = targetEntityType.resolvePath("@" + path.annotationPath);
-			// quickSelectionVariant = converterContext.getEntityTypeAnnotation(path.annotationPath);
-			if (quickSelectionVariant) {
-				quickFilterPaths.push({ annotationPath: path.annotationPath });
-			}
-			filters = {
-				quickFilters: {
-					enabled:
-						converterContext.getTemplateType() === TemplateType.ListReport
-							? "{= ${pageInternal>hasPendingFilters} !== true}"
-							: true,
-					showCounts: tableSettings?.quickVariantSelection?.showCounts,
-					paths: quickFilterPaths
-				}
-			};
-		});
-		creationMode = tableSettings.creationMode?.name || creationMode;
-		createAtEnd = tableSettings.creationMode?.createAtEnd !== undefined ? tableSettings.creationMode?.createAtEnd : true;
-		customValidationFunction = tableSettings.creationMode?.customValidationFunction;
-		// if a custom validation function is provided, disableAddRowButtonForEmptyData should not be considered, i.e. set to false
-		disableAddRowButtonForEmptyData = !customValidationFunction ? !!tableSettings.creationMode?.disableAddRowButtonForEmptyData : false;
-		condensedTableLayout = tableSettings.condensedTableLayout !== undefined ? tableSettings.condensedTableLayout : false;
-		hideTableTitle = !!tableSettings.quickVariantSelection?.hideTableTitle;
-		tableType = tableSettings?.type || "ResponsiveTable";
-		if (converterContext.getTemplateType() !== "ObjectPage") {
-			if (tableSettings?.type === "AnalyticalTable" && !aggregationHelper.isAnalyticsSupported()) {
-				tableType = "GridTable";
-			}
-			if (!tableSettings?.type) {
-				if (converterContext.getManifestWrapper().isDesktop() && aggregationHelper.isAnalyticsSupported()) {
-					tableType = "AnalyticalTable";
-				} else {
-					tableType = "ResponsiveTable";
-				}
-			}
-		}
-		enableFullScreen = tableSettings.enableFullScreen || false;
-		if (enableFullScreen === true && converterContext.getTemplateType() === TemplateType.ListReport) {
-			enableFullScreen = false;
-			converterContext
-				.getDiagnostics()
-				.addIssue(IssueCategory.Manifest, IssueSeverity.Low, IssueType.FULLSCREENMODE_NOT_ON_LISTREPORT);
-		}
-		selectionLimit = tableSettings.selectAll === true || tableSettings.selectionLimit === 0 ? 0 : tableSettings.selectionLimit || 200;
-		if (tableType === "ResponsiveTable") {
-			if (
-				converterContext.getTemplateType() === TemplateType.ListReport ||
-				converterContext.getTemplateType() === TemplateType.AnalyticalListPage
-			) {
-				multiSelectMode = !!tableSettings.selectAll ? "Default" : "ClearAll";
-			}
-			if (converterContext.getTemplateType() === TemplateType.ObjectPage) {
-				if (converterContext.getManifestWrapper().useIconTabBar()) {
-					multiSelectMode = !!tableSettings.selectAll ? "Default" : "ClearAll";
-				} else {
-					multiSelectMode = tableSettings.selectAll === false ? "ClearAll" : "Default";
-				}
-			}
-		}
-		enablePaste = converterContext.getTemplateType() === "ObjectPage" && tableSettings.enablePaste !== false;
-		enableExport =
-			tableSettings.enableExport !== undefined
-				? tableSettings.enableExport
-				: converterContext.getTemplateType() !== "ObjectPage" || enablePaste;
-	}
-	return {
-		filters: filters,
-		type: tableType,
-		enableFullScreen: enableFullScreen,
-		headerVisible: !(quickSelectionVariant && hideTableTitle),
-		enableExport: enableExport,
-		creationMode: creationMode,
-		createAtEnd: createAtEnd,
-		disableAddRowButtonForEmptyData: disableAddRowButtonForEmptyData,
+	const tableType: TableType = _getTableType(tableSettings, aggregationHelper, converterContext);
+	const oConfiguration = {
+		createAtEnd: tableSettings.creationMode?.createAtEnd !== undefined ? tableSettings.creationMode?.createAtEnd : true,
+		creationMode: tableSettings.creationMode?.name || creationMode,
 		customValidationFunction: customValidationFunction,
-		useCondensedTableLayout: condensedTableLayout && isCondensedTableLayoutCompliant,
-		selectionLimit: selectionLimit,
-		multiSelectMode: multiSelectMode,
+		dataStateIndicatorFilter: dataStateIndicatorFilter,
+		// 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,
+		enableExport: _getEnableExport(tableSettings, converterContext, enablePaste),
+		enableFullScreen: _getFullScreenBasedOnDevice(tableSettings, converterContext, converterContext.getManifestWrapper().isPhone()),
+		enableMassEdit: tableSettings?.enableMassEdit,
 		enablePaste: enablePaste,
+		headerVisible: true,
+		multiSelectMode: _getMultiSelectMode(tableSettings, tableType, converterContext),
+		selectionLimit: tableSettings.selectAll === true || tableSettings.selectionLimit === 0 ? 0 : tableSettings.selectionLimit || 200,
+
 		showRowCount:
 			!tableSettings?.quickVariantSelection?.showCounts && !converterContext.getManifestWrapper().getViewConfiguration()?.showCounts,
-		enableMassEdit: tableSettings?.enableMassEdit,
-		enableAutoColumnWidth: enableAutoColumnWidth
+		type: tableType,
+		useCondensedTableLayout: condensedTableLayout && isCondensedTableLayoutCompliant
+	};
+
+	return { ...oConfiguration, ...oFilterConfiguration };
+}
+
+export type configTypeConstraints = {
+	scale?: number;
+	precision?: number;
+	maxLength?: number;
+	nullable?: boolean;
+	minimum?: string;
+	maximum?: string;
+	isDigitSequence?: boolean;
+};
+
+export type configTypeformatOptions = {
+	parseAsString?: boolean;
+	emptyString?: string;
+	parseKeepsEmptyString?: boolean;
+};
+
+export type configType = {
+	type: string;
+	constraints: configTypeConstraints;
+	formatOptions: configTypeformatOptions;
+};
+
+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);
+	if (!oTargetMapping && (oProperty as Property)?.targetType && (oProperty as Property).targetType?._type === "TypeDefinition") {
+		oTargetMapping = EDM_TYPE_MAPPING[((oProperty as Property).targetType as TypeDefinition).underlyingType];
+	}
+	const propertyTypeConfig: configType = {
+		type: oTargetMapping?.type,
+		constraints: {},
+		formatOptions: {}
+	};
+	if (isProperty(oProperty)) {
+		propertyTypeConfig.constraints = {
+			scale: oTargetMapping.constraints?.$Scale ? oProperty.scale : undefined,
+			precision: oTargetMapping.constraints?.$Precision ? oProperty.precision : undefined,
+			maxLength: oTargetMapping.constraints?.$MaxLength ? oProperty.maxLength : undefined,
+			nullable: oTargetMapping.constraints?.$Nullable ? oProperty.nullable : undefined,
+			minimum:
+				oTargetMapping.constraints?.["@Org.OData.Validation.V1.Minimum/$Decimal"] &&
+				!isNaN(oProperty.annotations?.Validation?.Minimum)
+					? `${oProperty.annotations?.Validation?.Minimum}`
+					: undefined,
+			maximum:
+				oTargetMapping.constraints?.["@Org.OData.Validation.V1.Maximum/$Decimal"] &&
+				!isNaN(oProperty.annotations?.Validation?.Maximum)
+					? `${oProperty.annotations?.Validation?.Maximum}`
+					: undefined,
+			isDigitSequence:
+				propertyTypeConfig.type === "sap.ui.model.odata.type.String" &&
+				oTargetMapping.constraints?.["@com.sap.vocabularies.Common.v1.IsDigitSequence"] &&
+				(oProperty as Property).annotations?.Common?.IsDigitSequence
+					? true
+					: undefined
+		};
+	}
+	propertyTypeConfig.formatOptions = {
+		parseAsString:
+			propertyTypeConfig?.type?.indexOf("sap.ui.model.odata.type.Int") === 0 ||
+			propertyTypeConfig?.type?.indexOf("sap.ui.model.odata.type.Double") === 0
+				? false
+				: undefined,
+		emptyString:
+			propertyTypeConfig?.type?.indexOf("sap.ui.model.odata.type.Int") === 0 ||
+			propertyTypeConfig?.type?.indexOf("sap.ui.model.odata.type.Double") === 0
+				? ""
+				: undefined,
+		parseKeepsEmptyString: propertyTypeConfig.type === "sap.ui.model.odata.type.String" ? true : undefined
 	};
+	return propertyTypeConfig;
 }