@sapui5/sap.fe.core 1.95.0 → 1.98.0

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

@@ -7,11 +7,11 @@ import {
 	DataFieldForIntentBasedNavigation,
 	DataFieldTypes,
 	DataPoint,
+	DataPointTypeTypes,
 	EnumValue,
 	LineItem,
 	PathAnnotationExpression,
 	PresentationVariantTypeTypes,
-	PropertyAnnotationValue,
 	PropertyPath,
 	SelectionVariantType,
 	SelectOptionType,
@@ -34,7 +34,7 @@ import {
 	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,
@@ -49,6 +49,7 @@ import {
 	collectRelatedProperties,
 	collectRelatedPropertiesRecursively,
 	ComplexPropertyInfo,
+	getDataFieldDataType,
 	getSemanticObjectPath,
 	isDataFieldAlwaysHidden,
 	isDataFieldForActionAbstract,
@@ -67,13 +68,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 { Draft, 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";
@@ -82,12 +82,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 * as Edm from "@sap-ux/vocabularies-types/dist/Edm";
+import { IssueCategory, IssueSeverity, IssueType, IssueCategoryType } from "sap/fe/core/converters/helpers/IssueManager";
 
 import ManifestWrapper from "../../ManifestWrapper";
 import ConverterContext from "../../ConverterContext";
@@ -98,11 +96,23 @@ import {
 	isPathExpression,
 	getTargetValueOnDataPoint
 } from "sap/fe/core/templating/PropertyHelper";
-
 import { AggregationHelper } from "../../helpers/Aggregation";
-import { DisplayMode, getDisplayMode } 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
+} from "./table/StandardActions";
 
 export type TableAnnotationConfiguration = {
 	autoBindOnInit: boolean;
@@ -119,11 +129,9 @@ 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;
 	};
 	displayMode?: boolean;
 	threshold: number;
@@ -134,7 +142,6 @@ export type TableAnnotationConfiguration = {
 
 	/** Create new entries */
 	create: CreateBehaviour | CreateBehaviourExternal;
-	parentEntityDeleteEnabled?: BindingExpression<boolean>;
 	title: string;
 	searchable: boolean;
 };
@@ -196,6 +203,7 @@ export type TableControlConfiguration = {
 	enableFullScreen: boolean;
 	showRowCount: boolean;
 	enableMassEdit: boolean | undefined;
+	enableAutoColumnWidth: boolean;
 };
 
 export type TableType = "GridTable" | "ResponsiveTable" | "AnalyticalTable";
@@ -231,9 +239,12 @@ export type AnnotationTableColumn = BaseTableColumn & {
 	annotationPath: string;
 	relativePath: string;
 	label?: string;
+	tooltip?: string;
 	groupLabel?: string;
 	group?: string;
 	isGroupable?: boolean;
+	FieldGroupHiddenExpressions?: BindingExpression<string>;
+	showDataFieldsLabel?: boolean;
 	isKey?: boolean;
 	unit?: string;
 	exportSettings?: {
@@ -241,6 +252,13 @@ export type AnnotationTableColumn = BaseTableColumn & {
 		label?: string;
 		fieldLabel?: string;
 		wrap?: boolean;
+		type?: string;
+		inputFormat?: string;
+		format?: string;
+		scale?: number;
+		delimiter?: boolean;
+		trueValue?: boolean;
+		falseValue?: boolean;
 	};
 	isDataPointFakeTargetProperty?: boolean;
 	textArrangement?: {
@@ -249,6 +267,23 @@ export type AnnotationTableColumn = BaseTableColumn & {
 	};
 	exportContactProperty?: string;
 	additionalPropertyInfos?: string[];
+	visualSettings?: VisualSettings;
+	typeConfig?: object;
+};
+
+export type VisualSettings = {
+	widthCalculation?: WidthCalculation;
+};
+
+export type WidthCalculation = null | {
+	minWidth?: number;
+	maxWidth?: number;
+	defaultWidth?: number;
+	includeLabel?: boolean;
+	gap?: number;
+	// only relevant for complex types
+	excludeProperties?: string | string[];
+	verticalArrangement?: boolean;
 };
 
 export type TableColumn = CustomTableColumn | AnnotationTableColumn;
@@ -270,6 +305,7 @@ export type TableVisualization = {
 	actions: BaseAction[];
 	aggregates?: Record<string, AggregateData>;
 	enableAnalytics?: boolean;
+	enableAnalyticsSearch?: boolean;
 	enableDataStateFilter: boolean;
 	operationAvailableMap: string;
 	operationAvailableProperties: string;
@@ -462,6 +498,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(
@@ -881,7 +921,8 @@ export function getSelectionMode(
 	visualizationPath: string,
 	converterContext: ConverterContext,
 	isEntitySet: boolean,
-	targetCapabilities: TableCapabilityRestriction
+	targetCapabilities: TableCapabilityRestriction,
+	isDeleteButtonVisible?: Expression<boolean>
 ): string | undefined {
 	if (!lineItemAnnotation) {
 		return SelectionMode.None;
@@ -902,25 +943,10 @@ export function getSelectionMode(
 		isParentDeletable = isPathDeletable(converterContext.getDataModelObjectPath(), undefined);
 		parentEntitySetDeletable = isParentDeletable ? compileBinding(isParentDeletable, true) : isParentDeletable;
 	}
-	if (selectionMode && selectionMode === SelectionMode.None) {
-		if (!isEntitySet) {
-			if (targetCapabilities.isDeletable || parentEntitySetDeletable !== "false") {
-				selectionMode = SelectionMode.Multi;
-				return compileBinding(
-					ifElse(equal(bindingExpression("/editMode", "ui"), "Editable"), constant(selectionMode), constant("None"))
-				);
-			} else {
-				selectionMode = SelectionMode.None;
-			}
-		} else if (isEntitySet) {
-			if (targetCapabilities.isDeletable) {
-				selectionMode = SelectionMode.Multi;
-				return selectionMode;
-			} else {
-				selectionMode = SelectionMode.None;
-			}
-		}
-	} else if (!selectionMode || selectionMode === SelectionMode.Auto) {
+	if (selectionMode && selectionMode === SelectionMode.None && isDeleteButtonVisible) {
+		return compileBinding(ifElse(isDeleteButtonVisible, constant("Multi"), constant("None")));
+	}
+	if (!selectionMode || selectionMode === SelectionMode.Auto) {
 		selectionMode = SelectionMode.Multi;
 	}
 
@@ -939,18 +965,22 @@ export function getSelectionMode(
 	aVisibleBindingExpressions = getVisibleExpForCustomActionsRequiringContext(manifestActions);
 
 	// No action requiring a context:
-	if (aHiddenBindingExpressions.length === 0 && aVisibleBindingExpressions.length === 0) {
+	if (aHiddenBindingExpressions.length === 0 && aVisibleBindingExpressions.length === 0 && isDeleteButtonVisible) {
 		if (!isEntitySet) {
 			if (targetCapabilities.isDeletable || parentEntitySetDeletable !== "false") {
 				return compileBinding(
-					ifElse(equal(bindingExpression("/editMode", "ui"), "Editable"), constant(selectionMode), constant(SelectionMode.None))
+					ifElse(
+						and(equal(bindingExpression("/editMode", "ui"), "Editable"), isDeleteButtonVisible),
+						constant(selectionMode),
+						constant(SelectionMode.None)
+					)
 				);
 			} else {
 				return SelectionMode.None;
 			}
 			// EntitySet deletable:
-		} else if (targetCapabilities.isDeletable) {
-			return selectionMode;
+		} else if (targetCapabilities.isDeletable && isDeleteButtonVisible) {
+			return compileBinding(ifElse(isDeleteButtonVisible, constant(selectionMode), constant("None")));
 			// EntitySet not deletable:
 		} else {
 			return SelectionMode.None;
@@ -1111,10 +1141,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
 		};
@@ -1320,12 +1350,31 @@ const getColumnDefinitionFromProperty = function(
 	const groupPath: string | undefined = property.name ? _sliceAtSlash(property.name, true, false) : undefined;
 	const isGroup: boolean = groupPath != property.name;
 	const isDataPointFakeProperty: boolean = name.indexOf("@com.sap.vocabularies.UI.v1.DataPoint") > -1;
+	const exportType: string = _getExportDataType(property.type);
+	const sDateInputFormat: string | undefined = property.type === "Edm.Date" ? "YYYY-MM-DD" : undefined;
+	const dataType: string | undefined = getDataFieldDataType(property);
+	const propertyTypeConfig = !isDataPointFakeProperty ? getTypeConfig(property, dataType) : undefined;
+	const oTypeConfig = !isDataPointFakeProperty
+		? {
+				className: property.type || dataType,
+				oFormatOptions: propertyTypeConfig.formatOptions,
+				oConstraints: propertyTypeConfig.constraints
+		  }
+		: undefined;
 	const exportSettings = isDataPointFakeProperty
 		? {
 				template: getTargetValueOnDataPoint(property)
 		  }
-		: undefined;
-	return {
+		: {
+				type: exportType,
+				inputFormat: sDateInputFormat,
+				scale: property.scale,
+				delimiter: property.type === "Edm.Int64" ? true : false,
+				trueValue: property.type === "Edm.Boolean" ? "Yes" : undefined,
+				falseValue: property.type === "Edm.Boolean" ? "No" : undefined
+		  };
+
+	const oColumn: any = {
 		key: key,
 		isGroupable: !isDataPointFakeProperty && !isHidden ? aggregationHelper.isPropertyGroupable(property) : false,
 		type: ColumnType.Annotation,
@@ -1345,8 +1394,16 @@ const getColumnDefinitionFromProperty = function(
 		isKey: property.isKey,
 		isDataPointFakeTargetProperty: isDataPointFakeProperty,
 		exportSettings: exportSettings,
-		caseSensitive: isFilteringCaseSensitive(converterContext)
-	} as AnnotationTableColumn;
+		caseSensitive: isFilteringCaseSensitive(converterContext),
+		typeConfig: oTypeConfig,
+		visualSettings: isDataPointFakeProperty ? { widthCalculation: null } : undefined
+	};
+	const sTooltip = _getTooltip(property);
+	if (sTooltip) {
+		oColumn.tooltip = sTooltip;
+	}
+
+	return oColumn as AnnotationTableColumn;
 };
 
 /**
@@ -1376,8 +1433,91 @@ const _isValidColumn = function(dataField: DataFieldAbstractTypes) {
 };
 
 /**
- * Returns label for property and dataField.
- * @param {DataFieldAbstractTypes | Property} property Entity type property or DataField defined in the annotations
+ * Returns the binding expression to evaluate the visibility of a DataField or DataPoint annotation.
+ *
+ * SAP Fiori elements will evaluate either the UI.Hidden annotation defined on the annotation itself or on the target property.
+ *
+ * @param {DataModelObjectPath} dataFieldModelPath The metapath referring to the annotation that is evaluated by SAP Fiori elements.
+ * @param {FieldFormatOptions} [formatOptions] FormatOptions is optional, used to check if the analytic table has GroupHeader expanded.
+ * @param {boolean} [returnExpression] ReturnExpression optional.
+ * @returns {BindingExpression<string>} An expression that you can bind to the UI.
+ */
+export const _getVisibleExpression = function(
+	dataFieldModelPath: DataModelObjectPath,
+	formatOptions?: any,
+	returnExpression?: Boolean
+): BindingExpression<string> {
+	const targetObject: DataFieldAbstractTypes | DataPointTypeTypes = dataFieldModelPath.targetObject;
+	let propertyValue;
+	if (targetObject) {
+		switch (targetObject.$Type) {
+			case UIAnnotationTypes.DataField:
+			case UIAnnotationTypes.DataFieldWithUrl:
+			case UIAnnotationTypes.DataFieldWithNavigationPath:
+			case UIAnnotationTypes.DataFieldWithIntentBasedNavigation:
+			case UIAnnotationTypes.DataFieldWithAction:
+			case UIAnnotationTypes.DataPointType:
+				propertyValue = targetObject.Value.$target;
+				break;
+			case UIAnnotationTypes.DataFieldForAnnotation:
+				// if it is a DataFieldForAnnotation pointing to a DataPoint we look at the dataPoint's value
+				if (targetObject?.Target?.$target?.$Type === UIAnnotationTypes.DataPointType) {
+					propertyValue = targetObject.Target.$target?.Value.$target;
+				}
+				break;
+			case UIAnnotationTypes.DataFieldForIntentBasedNavigation:
+			case UIAnnotationTypes.DataFieldForAction:
+			default:
+				propertyValue = undefined;
+		}
+	}
+	const isAnalyticalGroupHeaderExpanded = formatOptions?.isAnalytics ? UI.IsExpanded : constant(false);
+	const isAnalyticalLeaf = formatOptions?.isAnalytics ? equal(UI.NodeLevel, 0) : constant(false);
+
+	// A data field is visible if:
+	// - the UI.Hidden expression in the original annotation does not evaluate to 'true'
+	// - the UI.Hidden expression in the target property does not evaluate to 'true'
+	// - in case of Analytics it's not visible for an expanded GroupHeader
+	const expression = and(
+		...[
+			not(equal(annotationExpression(targetObject?.annotations?.UI?.Hidden), true)),
+			ifElse(!!propertyValue, propertyValue && not(equal(annotationExpression(propertyValue.annotations?.UI?.Hidden), true)), true),
+			or(not(isAnalyticalGroupHeaderExpanded), isAnalyticalLeaf)
+		]
+	);
+	return returnExpression ? (expression as BindingExpression<string>) : compileBinding(expression);
+};
+
+/**
+ * Returns hidden binding expressions for a field group.
+ * @param {DataFieldAbstractTypes} dataFieldGroup DataField defined in the annotations
+ * @param {FieldFormatOptions} [fieldFormatOptions] FormatOptions is optional, used to check if the analytic table has GroupHeader expanded.
+ * @returns {BindingExpression<string>} Compile binding of field group expressions.
+ * @private
+ */
+const _getFieldGroupHiddenExpressions = function(
+	dataFieldGroup: DataFieldAbstractTypes,
+	fieldFormatOptions: any
+): BindingExpression<string> {
+	const aFieldGroupHiddenExpressions: BindingExpression<string>[] = [];
+	if (
+		dataFieldGroup.$Type === UIAnnotationTypes.DataFieldForAnnotation &&
+		dataFieldGroup.Target?.$target?.$Type === UIAnnotationTypes.FieldGroupType
+	) {
+		dataFieldGroup.Target.$target.Data?.forEach((innerDataField: DataFieldAbstractTypes | DataPointTypeTypes) => {
+			aFieldGroupHiddenExpressions.push(
+				_getVisibleExpression({ targetObject: innerDataField } as DataModelObjectPath, fieldFormatOptions, true)
+			);
+		});
+		return compileBinding(
+			ifElse(or(...(aFieldGroupHiddenExpressions as ExpressionOrPrimitive<boolean>[])), constant(true), constant(false))
+		);
+	}
+};
+
+/**
+ * Returns the label for the property and dataField.
+ * @param {DataFieldAbstractTypes | Property} [property] Property or DataField defined in the annotations
  * @param isGroup
  * @returns {string} Label of the property or DataField
  * @private
@@ -1412,6 +1552,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.
  *
@@ -1517,6 +1680,25 @@ const _getAnnotationColumnName = function(dataField: DataFieldAbstractTypes) {
 	}
 };
 
+/**
+ * Determines if the data field labels have to be displayed in the table.
+ * @param {string} fieldGroupName The `DataField` name being processed.
+ * @param {string} visualizationPath
+ * @param {ConverterContext} converterContext
+ * @returns {boolean} `showDataFieldsLabel` value from the manifest
+ * @private
+ */
+const _getShowDataFieldsLabel = function(fieldGroupName: string, visualizationPath: string, converterContext: ConverterContext): boolean {
+	const oColumns = converterContext.getManifestControlConfiguration(visualizationPath)?.columns;
+	const aColumnKeys = oColumns && Object.keys(oColumns);
+	return (
+		aColumnKeys &&
+		!!aColumnKeys.find(function(key: string) {
+			return key === fieldGroupName && oColumns[key].showDataFieldsLabel;
+		})
+	);
+};
+
 /**
  * Determines the relative path of the property with respect to the root entity.
  * @param dataField The `DataField` being processed.
@@ -1650,16 +1832,13 @@ const getColumnsFromAnnotations = function(
 	const entityType = converterContext.getAnnotationEntityType(lineItemAnnotation),
 		annotationColumns: AnnotationTableColumn[] = [],
 		columnsToBeCreated: Record<string, Property> = {},
-		nonSortableColumns: string[] =
-			(converterContext.getEntitySet()?.annotations?.Capabilities?.SortRestrictions
-				?.NonSortableProperties as Edm.PropertyPath[])?.map((property: PropertyPath) => property.value) ?? [],
+		nonSortableColumns: string[] = getNonSortablePropertiesRestrictions(converterContext.getEntitySet()),
 		tableManifestSettings: TableManifestConfiguration = converterContext.getManifestControlConfiguration(visualizationPath),
 		tableType: TableType = tableManifestSettings?.tableSettings?.type || "ResponsiveTable";
 	const semanticKeys = converterContext.getAnnotationsByTerm("Common", "com.sap.vocabularies.Common.v1.SemanticKey", [
 		converterContext.getEntityType()
 	])[0];
 	if (lineItemAnnotation) {
-		// Get columns from the LineItem Annotation
 		lineItemAnnotation.forEach(lineItem => {
 			if (!_isValidColumn(lineItem)) {
 				return;
@@ -1677,33 +1856,98 @@ const getColumnsFromAnnotations = function(
 			const isGroup: boolean = groupPath != relativePath;
 			const sLabel: string | undefined = _getLabel(lineItem, isGroup);
 			const name = _getAnnotationColumnName(lineItem);
-			annotationColumns.push({
+			const isFieldGroupColumn: boolean = groupPath.indexOf("@com.sap.vocabularies.UI.v1.FieldGroup") > -1;
+			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 = {
+				...getDefaultFormatOptionsForTable(),
+				...getDefaultDraftIndicatorForColumn(name, semanticKeys)
+			};
+			let fieldGroupHiddenExpressions: BindingExpression<string>;
+			if (
+				lineItem.$Type === UIAnnotationTypes.DataFieldForAnnotation &&
+				lineItem.Target?.$target?.$Type === UIAnnotationTypes.FieldGroupType
+			) {
+				fieldGroupHiddenExpressions = _getFieldGroupHiddenExpressions(lineItem, formatOptions);
+			}
+			const exportSettings = {
+				template: relatedPropertiesInfo.exportSettingsTemplate,
+				wrap: relatedPropertiesInfo.exportSettingsWrapping,
+				type: dataType ? _getExportDataType(dataType, relatedPropertyNames.length > 1) : undefined,
+				inputFormat: sDateInputFormat,
+				delimiter: dataType === "Edm.Int64" ? true : false,
+				trueValue: dataType === "Edm.Boolean" ? "Yes" : undefined,
+				falseValue: dataType === "Edm.Boolean" ? "No" : undefined
+			};
+			const propertyTypeConfig = dataType && getTypeConfig(lineItem, dataType);
+			const oTypeConfig = propertyTypeConfig
+				? {
+						className: dataType,
+						oFormatOptions: {
+							...formatOptions,
+							...propertyTypeConfig.formatOptions
+						},
+						oConstraints: propertyTypeConfig.constraints
+				  }
+				: undefined;
+			let visualSettings: VisualSettings = {};
+			if (relatedPropertiesInfo.visualSettingsToBeExcluded) {
+				// In case of text arrangement annotation with display mode as text only, exclude text property from the width calculation
+				visualSettings = {
+					widthCalculation: {
+						excludeProperties: "Property::" + relatedPropertiesInfo.visualSettingsToBeExcluded
+					}
+				};
+			} else if (!dataType || !oTypeConfig) {
+				// for charts
+				visualSettings.widthCalculation = null;
+			}
+
+			// 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,
 				groupLabel: isGroup ? _getLabel(lineItem) : null,
 				group: isGroup ? groupPath : null,
+				FieldGroupHiddenExpressions: fieldGroupHiddenExpressions,
 				annotationPath: converterContext.getEntitySetBasedAnnotationPath(lineItem.fullyQualifiedName),
 				semanticObjectPath: semanticObjectAnnotationPath,
 				availability: isDataFieldAlwaysHidden(lineItem) ? AvailabilityType.Hidden : AvailabilityType.Default,
 				name: name,
+				showDataFieldsLabel: showDataFieldsLabel,
 				relativePath: relativePath,
 				sortable: _isColumnSortable(lineItem, relativePath, nonSortableColumns),
 				propertyInfos: relatedPropertyNames.length > 0 ? relatedPropertyNames : undefined,
 				additionalPropertyInfos: additionalPropertyNames.length > 0 ? additionalPropertyNames : undefined,
-				exportSettings: {
-					template: relatedPropertiesInfo.exportSettingsTemplate,
-					wrap: relatedPropertiesInfo.exportSettingsWrapping
-				},
-				width: lineItem.annotations?.HTML5?.CssDefaults?.width || undefined,
+				exportSettings: exportSettings,
+				width: lineItem.annotations?.HTML5?.CssDefaults?.width || widthOverride || undefined,
 				isNavigable: true,
-				formatOptions: {
-					...getDefaultFormatOptionsForTable(),
-					...getDefaultDraftIndicatorForColumn(name, semanticKeys)
-				},
+				formatOptions: formatOptions,
 				exportContactProperty: relatedPropertiesInfo.exportSettingsContactProperty,
-				caseSensitive: isFilteringCaseSensitive(converterContext)
-			} as AnnotationTableColumn);
+				caseSensitive: isFilteringCaseSensitive(converterContext),
+				typeConfig: oTypeConfig,
+				visualSettings: visualSettings
+			};
+			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 => {
@@ -1834,36 +2078,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;
 };
@@ -1922,249 +2178,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 {BindingExpression<boolean>} The binding expression for the Delete button
- */
-export function getDeleteVisible(
-	converterContext: ConverterContext,
-	navigationPath: string,
-	isTargetDeletable: boolean,
-	viewConfiguration?: ViewPathConfiguration
-): BindingExpression<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;
-	}
-	//do not show case the delete button if parentEntitySetDeletable is false
-	if (parentEntitySetDeletable === "false") {
-		return false;
-	} else if (parentEntitySetDeletable && isDeleteHidden !== "true") {
-		//Delete Hidden in case of true and path based
-		if (isDeleteHidden && isDeleteHidden !== "false") {
-			return "{= !$" + isDeleteHidden + " && ${ui>/editMode} === 'Editable'}";
-		} else {
-			return "{= ${ui>/editMode} === 'Editable'}";
-		}
-	} else if (
-		isDeleteHidden === "true" ||
-		!isTargetDeletable ||
-		(viewConfiguration && converterContext.getManifestWrapper().hasMultipleVisualizations(viewConfiguration)) ||
-		converterContext.getTemplateType() === TemplateType.AnalyticalListPage
-	) {
-		return false;
-	} else if (converterContext.getTemplateType() !== TemplateType.ListReport) {
-		if (isDeleteHidden && isDeleteHidden === "false") {
-			return "{= !$" + isDeleteHidden + " && ${ui>/editMode} === 'Editable'}";
-		} else {
-			return "{= ${ui>/editMode} === 'Editable'}";
-		}
-	} else if (isBinding(isDeleteHiddenExpression)) {
-		// UI.DeleteHidden annotation points to a path
-		return compileBinding(not(isDeleteHiddenExpression));
-	} else {
-		return true;
-	}
-}
-
-/**
- * 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
- *
- * @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.
- *
- * @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.
+ * Returns a JSON string containing the sort conditions for the presentation variant.
  *
  * @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
- */
-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
-	);
-}
-
-/**
- * Returns a JSON string containing Presentation Variant sort conditions.
- *
  * @param {PresentationVariantTypeTypes | undefined} presentationVariantAnnotation Presentation variant annotation
- * @param columns Converter processed table columns
- * @returns {string | undefined} Sort conditions for a Presentation variant.
+ * @param columns Table columns processed by the converter
+ * @returns {string | undefined} Sort conditions for a presentation variant.
  */
 function getSortConditions(
+	converterContext: ConverterContext,
 	presentationVariantAnnotation: PresentationVariantTypeTypes | undefined,
 	columns: TableColumn[]
 ): string | undefined {
+	// Currently navigation property is not supported as sorter
+	const nonSortableProperties = getNonSortablePropertiesRestrictions(converterContext.getEntitySet());
 	let sortConditions: string | undefined;
 	if (presentationVariantAnnotation?.SortOrder) {
 		const sorters: SorterType[] = [];
@@ -2172,22 +2199,15 @@ function getSortConditions(
 			sorters: sorters
 		};
 		presentationVariantAnnotation.SortOrder.forEach(condition => {
-			const propertyName = (condition.Property as PropertyPath)?.$target?.name;
-			const sortColumn = columns.find(column => column.name === propertyName) as AnnotationTableColumn;
-			sortColumn?.propertyInfos?.forEach(relatedPropertyName => {
-				// Complex PropertyInfo. Add each related property for sorting.
-				conditions.sorters.push({
-					name: relatedPropertyName,
-					descending: !!condition.Descending
-				});
-			});
-
-			if (!sortColumn?.propertyInfos?.length) {
-				// Not a complex PropertyInfo. Consider the property itself for sorting.
-				conditions.sorters.push({
-					name: propertyName,
-					descending: !!condition.Descending
-				});
+			const conditionProperty = condition.Property;
+			if (conditionProperty && nonSortableProperties.indexOf(conditionProperty.$target?.name) === -1) {
+				const infoName = convertPropertyPathsToInfoNames([conditionProperty], columns)[0];
+				if (infoName) {
+					conditions.sorters.push({
+						name: infoName,
+						descending: !!condition.Descending
+					});
+				}
 			}
 		});
 		sortConditions = conditions.sorters.length ? JSON.stringify(conditions) : undefined;
@@ -2286,28 +2306,42 @@ export function getTableAnnotationConfiguration(
 		p13nMode: string | undefined = getP13nMode(visualizationPath, converterContext, tableManifestConfiguration),
 		id = navigationPropertyPath ? TableID(visualizationPath) : TableID(converterContext.getContextPath(), "LineItem");
 	const targetCapabilities = getCapabilityRestriction(converterContext);
-	const selectionMode = getSelectionMode(lineItemAnnotation, visualizationPath, converterContext, hasAbsolutePath, targetCapabilities);
+	const navigationTargetPath = getNavigationTargetPath(converterContext, navigationPropertyPath);
+	const navigationSettings = pageManifestSettings.getNavigationConfiguration(navigationTargetPath);
+	const standardActionsContext = generateStandardActionsContext(
+		converterContext,
+		navigationSettings,
+		tableManifestConfiguration,
+		viewConfiguration
+	);
+	const isDeleteButtonVisible = getDeleteVisibility(converterContext, standardActionsContext);
+	const selectionMode = getSelectionMode(
+		lineItemAnnotation,
+		visualizationPath,
+		converterContext,
+		hasAbsolutePath,
+		targetCapabilities,
+		isDeleteButtonVisible
+	);
 	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 tableActions = {
+		create: getStandardActionCreate(converterContext, standardActionsContext),
+		"delete": getStandardActionDelete(converterContext, standardActionsContext),
+		paste: getStandardActionPaste(converterContext, standardActionsContext),
+		massEdit: getStandardActionMassEdit(converterContext, standardActionsContext, selectionMode)
+	};
+	const isInsertUpdateTemplated = getInsertUpdateActionsTemplating(
+		standardActionsContext,
+		isDraftOrStickySupported(converterContext),
+		tableActions.create.visible === "false"
+	);
 
 	return {
 		id: id,
@@ -2322,22 +2356,9 @@ export function getTableAnnotationConfiguration(
 			navigationTargetPath
 		),
 		p13nMode: p13nMode,
-		show: {
-			"delete": getDeleteVisible(converterContext, navigationPropertyPath, targetCapabilities.isDeletable, viewConfiguration),
-			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: tableActions,
+			isInsertUpdateTemplated: isInsertUpdateTemplated
 		},
 		displayMode: isInDisplayMode(converterContext, viewConfiguration),
 		create: creationBehaviour,
@@ -2348,13 +2369,45 @@ export function getTableAnnotationConfiguration(
 			!(viewConfiguration && converterContext.getManifestWrapper().hasMultipleVisualizations(viewConfiguration)),
 		variantManagement: variantManagement === "Control" && !p13nMode ? VariantManagementType.None : variantManagement,
 		threshold: threshold,
-		sortConditions: getSortConditions(presentationVariantAnnotation, columns),
-		parentEntityDeleteEnabled: parentEntitySetDeletable,
+		sortConditions: getSortConditions(converterContext, presentationVariantAnnotation, columns),
 		title: title,
 		searchable: tableManifestConfiguration.type !== "AnalyticalTable" && !(isConstant(isSearchable) && isSearchable.value === false)
 	};
 }
 
+function _getExportDataType(dataType: string, isComplexProperty: boolean = false): string {
+	let exportDataType: string = "String";
+	if (isComplexProperty) {
+		return exportDataType;
+	} else {
+		switch (dataType) {
+			case "Edm.Decimal":
+			case "Edm.Int32":
+			case "Edm.Int64":
+			case "Edm.Double":
+			case "Edm.Byte":
+				exportDataType = "Number";
+				break;
+			case "Edm.DateOfTime":
+			case "Edm.Date":
+				exportDataType = "Date";
+				break;
+			case "Edm.DateTimeOffset":
+				exportDataType = "DateTime";
+				break;
+			case "Edm.TimeOfDay":
+				exportDataType = "Time";
+				break;
+			case "Edm.Boolean":
+				exportDataType = "Boolean";
+				break;
+			default:
+				exportDataType = "String";
+		}
+	}
+	return exportDataType;
+}
+
 function isInDisplayMode(converterContext: ConverterContext, viewConfiguration?: ViewPathConfiguration): boolean {
 	const templateType = converterContext.getTemplateType();
 	if (
@@ -2374,7 +2427,7 @@ function isInDisplayMode(converterContext: ConverterContext, viewConfiguration?:
  * @param visualizationPath
  * @returns {object}
  */
-function splitPath(visualizationPath: string) {
+export function splitPath(visualizationPath: string) {
 	let [navigationPropertyPath, annotationPath] = visualizationPath.split("@");
 
 	if (navigationPropertyPath.lastIndexOf("/") === navigationPropertyPath.length - 1) {
@@ -2430,7 +2483,9 @@ export function getTableManifestConfiguration(
 	let enableFullScreen = false;
 	let selectionLimit = 200;
 	let multiSelectMode;
-	let enablePaste = converterContext.getTemplateType() === "ObjectPage";
+	const enableAutoColumnWidth = !converterContext.getManifestWrapper().isPhone();
+	const enablePaste =
+		tableSettings.enablePaste !== undefined ? tableSettings.enablePaste : converterContext.getTemplateType() === "ObjectPage"; // Paste is disabled by default excepted for OP
 	const isCondensedTableLayoutCompliant = checkCondensedLayout && converterContext.getManifestWrapper().isCondensedLayoutCompliant();
 	const entityType = converterContext.getEntityType();
 	const aggregationHelper = new AggregationHelper(entityType, converterContext);
@@ -2473,8 +2528,14 @@ export function getTableManifestConfiguration(
 				}
 			}
 		}
-		enableFullScreen = tableSettings.enableFullScreen || false;
-		if (enableFullScreen === true && converterContext.getTemplateType() === TemplateType.ListReport) {
+		// If enableFullScreen is not set, use as default true on phone and false otherwise
+		enableFullScreen = tableSettings.enableFullScreen ?? converterContext.getManifestWrapper().isPhone();
+		// Make sure that enableFullScreen is not set on ListReport for desktop or tablet
+		if (
+			!converterContext.getManifestWrapper().isPhone() &&
+			enableFullScreen &&
+			converterContext.getTemplateType() === TemplateType.ListReport
+		) {
 			enableFullScreen = false;
 			converterContext
 				.getDiagnostics()
@@ -2496,7 +2557,6 @@ export function getTableManifestConfiguration(
 				}
 			}
 		}
-		enablePaste = converterContext.getTemplateType() === "ObjectPage" && tableSettings.enablePaste !== false;
 		enableExport =
 			tableSettings.enableExport !== undefined
 				? tableSettings.enableExport
@@ -2518,6 +2578,79 @@ export function getTableManifestConfiguration(
 		enablePaste: enablePaste,
 		showRowCount:
 			!tableSettings?.quickVariantSelection?.showCounts && !converterContext.getManifestWrapper().getViewConfiguration()?.showCounts,
-		enableMassEdit: tableSettings?.enableMassEdit
+		enableMassEdit: tableSettings?.enableMassEdit,
+		enableAutoColumnWidth: enableAutoColumnWidth
+	};
+}
+
+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;
 }