@sapui5/sap.fe.core 1.99.0 → 1.101.1

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

@@ -1,3 +1,4 @@
+import { EntityType, Property, TypeDefinition } from "@sap-ux/annotation-converter";
 import {
 	CriticalityType,
 	DataField,
@@ -9,6 +10,7 @@ import {
 	DataPoint,
 	DataPointTypeTypes,
 	EnumValue,
+	FieldGroupType,
 	LineItem,
 	PathAnnotationExpression,
 	PresentationVariantTypeTypes,
@@ -17,35 +19,9 @@ import {
 	SelectOptionType,
 	UIAnnotationTypes
 } from "@sap-ux/vocabularies-types";
-import {
-	ActionType,
-	AvailabilityType,
-	CreationMode,
-	FormatOptionsType,
-	HorizontalAlign,
-	ManifestTableColumn,
-	NavigationSettingsConfiguration,
-	NavigationTargetConfiguration,
-	SelectionMode,
-	TableColumnSettings,
-	TableManifestConfiguration,
-	TableManifestSettingsConfiguration,
-	TemplateType,
-	VariantManagementType,
-	ViewPathConfiguration,
-	VisualizationType
-} from "../../ManifestSettings";
-import { EntityType, Property, TypeDefinition } from "@sap-ux/annotation-converter";
-import { TableID } from "../../helpers/ID";
-import {
-	AnnotationAction,
-	BaseAction,
-	CustomAction,
-	getActionsFromManifest,
-	isActionNavigable,
-	removeDuplicateActions
-} from "sap/fe/core/converters/controls/Common/Action";
-import { ConfigurableObject, CustomElement, insertCustomElements, Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
+import { FilterFunctions } from "@sap-ux/vocabularies-types/dist/generated/Capabilities";
+import { CommonAnnotationTerms } from "@sap-ux/vocabularies-types/dist/generated/Common";
+import { SemanticKey } from "@sap-ux/vocabularies-types/types/generated/Common";
 import {
 	collectRelatedProperties,
 	collectRelatedPropertiesRecursively,
@@ -56,6 +32,20 @@ import {
 	isDataFieldForActionAbstract,
 	isDataFieldTypes
 } from "sap/fe/core/converters/annotations/DataField";
+import {
+	AnnotationAction,
+	BaseAction,
+	CustomAction,
+	getActionsFromManifest,
+	isActionNavigable,
+	removeDuplicateActions
+} from "sap/fe/core/converters/controls/Common/Action";
+import { bindingContextPathVisitor, Entity, UI } from "sap/fe/core/converters/helpers/BindingHelper";
+import { ConfigurableObject, CustomElement, insertCustomElements, Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
+import { IssueCategory, IssueCategoryType, IssueSeverity, IssueType } from "sap/fe/core/converters/helpers/IssueManager";
+import { KeyHelper } from "sap/fe/core/converters/helpers/Key";
+import tableFormatters from "sap/fe/core/formatters/TableFormatter";
+import { MessageType } from "sap/fe/core/formatters/TableFormatterTypes";
 import {
 	and,
 	annotationExpression,
@@ -74,10 +64,7 @@ import {
 	or,
 	resolveBindingString
 } from "sap/fe/core/helpers/BindingExpression";
-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";
+import { replaceSpecialChars } from "sap/fe/core/helpers/StableIdHelper";
 import {
 	DataModelObjectPath,
 	getTargetObjectPath,
@@ -85,38 +72,54 @@ import {
 	isPathSearchable,
 	isPathUpdatable
 } from "sap/fe/core/templating/DataModelPathHelper";
-import { replaceSpecialChars } from "sap/fe/core/helpers/StableIdHelper";
-import { IssueCategory, IssueSeverity, IssueType, IssueCategoryType } from "sap/fe/core/converters/helpers/IssueManager";
-
-import ManifestWrapper from "../../ManifestWrapper";
-import ConverterContext from "../../ConverterContext";
+import { DisplayMode, EDM_TYPE_MAPPING, getDisplayMode } from "sap/fe/core/templating/DisplayModeFormatter";
+import { getNonSortablePropertiesRestrictions } from "sap/fe/core/templating/EntitySetHelper";
 import {
-	isProperty,
-	getAssociatedUnitProperty,
 	getAssociatedCurrencyProperty,
+	getAssociatedUnitProperty,
+	getTargetValueOnDataPoint,
 	isPathExpression,
-	getTargetValueOnDataPoint
+	isProperty
 } from "sap/fe/core/templating/PropertyHelper";
+import ConverterContext from "../../ConverterContext";
 import { AggregationHelper } from "../../helpers/Aggregation";
-import { DisplayMode, EDM_TYPE_MAPPING, getDisplayMode } from "sap/fe/core/templating/DisplayModeFormatter";
+import { TableID } from "../../helpers/ID";
+import {
+	ActionType,
+	AvailabilityType,
+	CreationMode,
+	FormatOptionsType,
+	HorizontalAlign,
+	Importance,
+	ManifestTableColumn,
+	NavigationSettingsConfiguration,
+	NavigationTargetConfiguration,
+	SelectionMode,
+	TableColumnSettings,
+	TableManifestConfiguration,
+	TableManifestSettingsConfiguration,
+	TemplateType,
+	VariantManagementType,
+	ViewPathConfiguration,
+	VisualizationType
+} from "../../ManifestSettings";
+import ManifestWrapper from "../../ManifestWrapper";
 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,
+	getCreateVisibility,
+	getCreationRow,
 	getDeleteVisibility,
+	getInsertUpdateActionsTemplating,
+	getMassEditVisibility,
+	getRestrictions,
 	getStandardActionCreate,
 	getStandardActionDelete,
-	getStandardActionPaste,
 	getStandardActionMassEdit,
+	getStandardActionPaste,
 	isDraftOrStickySupported,
-	getInsertUpdateActionsTemplating,
-	getCreateVisibility,
 	isInDisplayMode,
-	getMassEditVisibility,
-	getRestrictions
+	StandardActionConfigType
 } from "./table/StandardActions";
 
 export type TableAnnotationConfiguration = {
@@ -147,7 +150,7 @@ export type TableAnnotationConfiguration = {
 	aggregateConditions?: string;
 
 	/** Create new entries */
-	create: CreateBehaviour | CreateBehaviourExternal;
+	create: CreateBehavior | CreateBehaviorExternal;
 	title: string;
 	searchable: boolean;
 };
@@ -155,9 +158,9 @@ export type TableAnnotationConfiguration = {
 /**
  * New entries are created within the app (default case)
  */
-type CreateBehaviour = {
+type CreateBehavior = {
 	mode: CreationMode;
-	append: Boolean;
+	append: boolean;
 	newAction?: string;
 	navigateToTarget?: string;
 };
@@ -165,7 +168,7 @@ type CreateBehaviour = {
 /**
  * New entries are created by navigating to some target
  */
-type CreateBehaviourExternal = {
+type CreateBehaviorExternal = {
 	mode: "External";
 	outbound: string;
 	outboundDetail: NavigationTargetConfiguration["outboundDetail"];
@@ -235,6 +238,7 @@ export type BaseTableColumn = ConfigurableObject & {
 	sortable: boolean;
 	horizontalAlign?: HorizontalAlign;
 	formatOptions: FormatOptionsType;
+	importance: string;
 };
 
 export type CustomTableColumn = BaseTableColumn & {
@@ -267,6 +271,8 @@ export type AnnotationTableColumn = BaseTableColumn & {
 		delimiter?: boolean;
 		trueValue?: boolean;
 		falseValue?: boolean;
+		unit?: string;
+		unitProperty?: string;
 	};
 	isDataPointFakeTargetProperty?: boolean;
 	textArrangement?: {
@@ -290,7 +296,7 @@ export type WidthCalculation = null | {
 	includeLabel?: boolean;
 	gap?: number;
 	// only relevant for complex types
-	excludeProperties?: string | string[];
+	excludeProperties?: string[];
 	verticalArrangement?: boolean;
 };
 
@@ -388,6 +394,7 @@ export function getTableColumns(
 
 	return insertCustomElements(annotationColumns, manifestColumns, {
 		width: "overwrite",
+		importance: "overwrite",
 		isNavigable: "overwrite",
 		availability: "overwrite",
 		settings: "overwrite",
@@ -404,7 +411,7 @@ export function getTableColumns(
  * @param converterContext The converter context.
  * @returns The aggregate definitions from the entityType, or undefined if the entity doesn't support analytical queries.
  */
-export const getAggregateDefinitionsFromEntityType = function(
+export const getAggregateDefinitionsFromEntityType = function (
 	entityType: EntityType,
 	tableColumns: TableColumn[],
 	converterContext: ConverterContext
@@ -412,7 +419,7 @@ export const getAggregateDefinitionsFromEntityType = function(
 	const aggregationHelper = new AggregationHelper(entityType, converterContext);
 
 	function findColumnFromPath(path: string): TableColumn | undefined {
-		return tableColumns.find(column => {
+		return tableColumns.find((column) => {
 			const annotationColumn = column as AnnotationTableColumn;
 			return annotationColumn.propertyInfos === undefined && annotationColumn.relativePath === path;
 		});
@@ -425,7 +432,7 @@ export const getAggregateDefinitionsFromEntityType = function(
 	// Keep a set of all currency/unit properties, as we don't want to consider them as aggregates
 	// They are aggregates for technical reasons (to manage multi-units situations) but it doesn't make sense from a user standpoint
 	const mCurrencyOrUnitProperties = new Set();
-	tableColumns.forEach(oColumn => {
+	tableColumns.forEach((oColumn) => {
 		const oTableColumn = oColumn as AnnotationTableColumn;
 		if (oTableColumn.unit) {
 			mCurrencyOrUnitProperties.add(oTableColumn.unit);
@@ -435,15 +442,15 @@ export const getAggregateDefinitionsFromEntityType = function(
 	const aCustomAggregateAnnotations = aggregationHelper.getCustomAggregateDefinitions();
 	const mRawDefinitions: Record<string, string[]> = {};
 
-	aCustomAggregateAnnotations.forEach(annotation => {
-		const oAggregatedProperty = aggregationHelper._entityType.entityProperties.find(oProperty => {
+	aCustomAggregateAnnotations.forEach((annotation) => {
+		const oAggregatedProperty = aggregationHelper._entityType.entityProperties.find((oProperty) => {
 			return oProperty.name === annotation.qualifier;
 		});
 
 		if (oAggregatedProperty) {
 			const aContextDefiningProperties = annotation.annotations?.Aggregation?.ContextDefiningProperties;
 			mRawDefinitions[oAggregatedProperty.name] = aContextDefiningProperties
-				? aContextDefiningProperties.map(oCtxDefProperty => {
+				? aContextDefiningProperties.map((oCtxDefProperty) => {
 						return oCtxDefProperty.value;
 				  })
 				: [];
@@ -451,7 +458,7 @@ export const getAggregateDefinitionsFromEntityType = function(
 	});
 	const mResult: Record<string, AggregateData> = {};
 
-	tableColumns.forEach(oColumn => {
+	tableColumns.forEach((oColumn) => {
 		const oTableColumn = oColumn as AnnotationTableColumn;
 		if (oTableColumn.propertyInfos === undefined && oTableColumn.relativePath) {
 			const aRawContextDefiningProperties = mRawDefinitions[oTableColumn.relativePath];
@@ -467,7 +474,7 @@ export const getAggregateDefinitionsFromEntityType = function(
 					relativePath: oTableColumn.relativePath
 				};
 				const aContextDefiningProperties: string[] = [];
-				aRawContextDefiningProperties.forEach(contextDefiningPropertyName => {
+				aRawContextDefiningProperties.forEach((contextDefiningPropertyName) => {
 					const oColumn = findColumnFromPath(contextDefiningPropertyName);
 					if (oColumn) {
 						aContextDefiningProperties.push(oColumn.name);
@@ -555,13 +562,13 @@ function getNavigationTargetPath(converterContext: ConverterContext, navigationP
  */
 export function updateLinkedProperties(entityType: EntityType, tableColumns: TableColumn[]) {
 	function findColumnByPath(path: string): TableColumn | undefined {
-		return tableColumns.find(column => {
+		return tableColumns.find((column) => {
 			const annotationColumn = column as AnnotationTableColumn;
 			return annotationColumn.propertyInfos === undefined && annotationColumn.relativePath === path;
 		});
 	}
 
-	tableColumns.forEach(oColumn => {
+	tableColumns.forEach((oColumn) => {
 		const oTableColumn = oColumn as AnnotationTableColumn;
 		if (oTableColumn.propertyInfos === undefined && oTableColumn.relativePath) {
 			const oProperty = entityType.entityProperties.find((oProp: Property) => oProp.name === oTableColumn.relativePath);
@@ -671,14 +678,14 @@ export function createDefaultTableVisualization(converterContext: ConverterConte
  */
 function getOperationAvailableMap(lineItemAnnotation: LineItem | undefined, converterContext: ConverterContext): Record<string, any> {
 	const operationAvailableMap: Record<string, any> = {};
-	const addToMap = function(key: string, value: any) {
+	const addToMap = function (key: string, value: any) {
 		if (key) {
 			operationAvailableMap[key] = value;
 		}
 	};
 
 	if (lineItemAnnotation) {
-		lineItemAnnotation.forEach(dataField => {
+		lineItemAnnotation.forEach((dataField) => {
 			if (dataField.$Type === UIAnnotationTypes.DataFieldForAction) {
 				const actionName = dataField.Action as string;
 				if (actionName?.indexOf("/") < 0 && !dataField.Determining) {
@@ -719,7 +726,7 @@ function getCurrentEntitySetUpdatablePath(converterContext: ConverterContext): s
 	const restrictions = getRestrictions(converterContext);
 	const entitySet = converterContext.getEntitySet();
 	const updatable = restrictions.isUpdatable;
-	const isOnlyDynamicOnCurrentEntity: any = updatable.isOnlyCurrentEntityExpression && !isConstant(updatable.expression);
+	const isOnlyDynamicOnCurrentEntity: any = !isConstant(updatable.expression) && updatable.navigationExpression._type === "Unresolvable";
 	const updatablePropertyPath = (entitySet?.annotations.Capabilities?.UpdateRestrictions?.Updatable as any)?.path;
 
 	return isOnlyDynamicOnCurrentEntity ? (updatablePropertyPath as string) : "";
@@ -776,7 +783,7 @@ function getUIHiddenExpForActionsRequiringContext(
 	isEntitySet: boolean
 ): Expression<boolean>[] {
 	const aUiHiddenPathExpressions: Expression<boolean>[] = [];
-	lineItemAnnotation.forEach(dataField => {
+	lineItemAnnotation.forEach((dataField) => {
 		// Check if the lineItem context is the same as that of the action:
 		if (
 			(dataField.$Type === UIAnnotationTypes.DataFieldForAction &&
@@ -870,7 +877,7 @@ function getBindingExpFromContext(
  * @returns {boolean} `true` if there is at least 1 action that meets the criteria
  */
 function hasBoundActionsAlwaysVisibleInToolBar(lineItemAnnotation: LineItem, currentEntityType: EntityType): boolean {
-	return lineItemAnnotation.some(dataField => {
+	return lineItemAnnotation.some((dataField) => {
 		if (
 			(dataField.$Type === UIAnnotationTypes.DataFieldForAction ||
 				dataField.$Type === UIAnnotationTypes.DataFieldForIntentBasedNavigation) &&
@@ -889,7 +896,7 @@ function hasBoundActionsAlwaysVisibleInToolBar(lineItemAnnotation: LineItem, cur
 }
 
 function hasCustomActionsAlwaysVisibleInToolBar(manifestActions: Record<string, CustomAction>): boolean {
-	return Object.keys(manifestActions).some(actionKey => {
+	return Object.keys(manifestActions).some((actionKey) => {
 		const action = manifestActions[actionKey];
 		if (action.requiresSelection && action.visible?.toString() === "true") {
 			return true;
@@ -908,7 +915,7 @@ function hasCustomActionsAlwaysVisibleInToolBar(manifestActions: Record<string,
 function getVisibleExpForCustomActionsRequiringContext(manifestActions: Record<string, CustomAction>): Expression<boolean>[] {
 	const aVisiblePathExpressions: Expression<boolean>[] = [];
 	if (manifestActions) {
-		Object.keys(manifestActions).forEach(actionKey => {
+		Object.keys(manifestActions).forEach((actionKey) => {
 			const action = manifestActions[actionKey];
 			if (action.requiresSelection === true && action.visible !== undefined) {
 				if (typeof action.visible === "string") {
@@ -966,7 +973,7 @@ export function getSelectionMode(
 	);
 	let isParentDeletable, parentEntitySetDeletable;
 	if (converterContext.getTemplateType() === TemplateType.ObjectPage) {
-		isParentDeletable = isPathDeletable(converterContext.getDataModelObjectPath(), undefined);
+		isParentDeletable = isPathDeletable(converterContext.getDataModelObjectPath());
 		parentEntitySetDeletable = isParentDeletable ? compileBinding(isParentDeletable, true) : isParentDeletable;
 	}
 
@@ -976,7 +983,7 @@ export function getSelectionMode(
 			// Mass Edit in OP is enabled only in edit mode.
 			return compileBinding(
 				ifElse(
-					and(equal(bindingExpression("/editMode", "ui"), "Editable"), massEditVisibilityExpression),
+					and(UI.IsEditable, massEditVisibilityExpression),
 					constant("Multi"),
 					ifElse(deleteButtonVisibilityExpression, constant("Multi"), constant("None"))
 				)
@@ -1024,11 +1031,7 @@ export function getSelectionMode(
 					massEditVisibilityExpression
 				);
 				return compileBinding(
-					ifElse(
-						and(equal(bindingExpression("/editMode", "ui"), "Editable"), buttonVisibilityExpression),
-						constant(selectionMode),
-						constant(SelectionMode.None)
-					)
+					ifElse(and(UI.IsEditable, buttonVisibilityExpression), constant(selectionMode), constant(SelectionMode.None))
 				);
 			} else {
 				return SelectionMode.None;
@@ -1055,7 +1058,7 @@ export function getSelectionMode(
 			);
 			return compileBinding(
 				ifElse(
-					and(equal(bindingExpression("/editMode", "ui"), "Editable"), editModebuttonVisibilityExpression),
+					and(UI.IsEditable, editModebuttonVisibilityExpression),
 					constant(selectionMode),
 					ifElse(
 						or(...aHiddenBindingExpressions.concat(aVisibleBindingExpressions)),
@@ -1218,10 +1221,10 @@ function _getCreationBehaviour(
 	const navigation = navigationSettings?.create || navigationSettings?.detail;
 
 	// cross-app
-	if (isExternalCreateConfigured(navigationSettings) && navigation) {
+	if (navigation?.outbound && navigation.outboundDetail && navigationSettings?.create) {
 		return {
 			mode: "External",
-			outbound: navigation.outbound as string,
+			outbound: navigation.outbound,
 			outboundDetail: navigation.outboundDetail,
 			navigationSettings: navigationSettings
 		};
@@ -1261,7 +1264,7 @@ function _getCreationBehaviour(
 	};
 }
 
-const _getRowConfigurationProperty = function(
+const _getRowConfigurationProperty = function (
 	lineItemAnnotation: LineItem | undefined,
 	visualizationPath: string,
 	converterContext: ConverterContext,
@@ -1322,7 +1325,7 @@ const _getRowConfigurationProperty = function(
  * @param tableType The table type.
  * @returns {AnnotationTableColumn[]} The column from the entityType
  */
-export const getColumnsFromEntityType = function(
+export const getColumnsFromEntityType = function (
 	columnsToBeCreated: Record<string, Property>,
 	entityType: EntityType,
 	annotationColumns: AnnotationTableColumn[] = [],
@@ -1336,7 +1339,7 @@ export const getColumnsFromEntityType = function(
 
 	entityType.entityProperties.forEach((property: Property) => {
 		// Catch already existing columns - which were added before by LineItem Annotations
-		const exists = annotationColumns.some(column => {
+		const exists = annotationColumns.some((column) => {
 			return column.name === property.name;
 		});
 
@@ -1361,10 +1364,10 @@ export const getColumnsFromEntityType = function(
 				aggregationHelper,
 				converterContext
 			);
-			const semanticKeys = converterContext.getAnnotationsByTerm("Common", "com.sap.vocabularies.Common.v1.SemanticKey", [
+			const semanticKeys = converterContext.getAnnotationsByTerm("Common", CommonAnnotationTerms.SemanticKey, [
 				converterContext.getEntityType()
 			])[0];
-			const oColumnDraftIndicator = getDefaultDraftIndicatorForColumn(columnInfo.name, semanticKeys);
+			const oColumnDraftIndicator = getDefaultDraftIndicatorForColumn(columnInfo.name, semanticKeys, false, null);
 			if (Object.keys(oColumnDraftIndicator).length > 0) {
 				columnInfo.formatOptions = {
 					...oColumnDraftIndicator
@@ -1378,8 +1381,15 @@ export const getColumnsFromEntityType = function(
 					wrap: relatedPropertiesInfo.exportSettingsWrapping
 				};
 
+				if (relatedPropertiesInfo.exportUnitName) {
+					columnInfo.exportSettings.unitProperty = relatedPropertiesInfo.exportUnitName;
+					columnInfo.exportSettings.type = "Currency"; // Force to a currency because there's a unitProperty (otherwise the value isn't properly formatted when exported)
+				} else if (relatedPropertiesInfo.exportUnitString) {
+					columnInfo.exportSettings.unit = relatedPropertiesInfo.exportUnitString;
+				}
+
 				// Collect information of related columns to be created.
-				relatedPropertyNames.forEach(name => {
+				relatedPropertyNames.forEach((name) => {
 					columnsToBeCreated[name] = relatedPropertiesInfo.properties[name];
 				});
 			}
@@ -1387,7 +1397,7 @@ export const getColumnsFromEntityType = function(
 			if (additionalPropertyNames.length > 0) {
 				columnInfo.additionalPropertyInfos = additionalPropertyNames;
 				// Create columns for additional properties identified for ALP use case.
-				additionalPropertyNames.forEach(name => {
+				additionalPropertyNames.forEach((name) => {
 					// Intentional overwrite as we require only one new PropertyInfo for a related Property.
 					columnsToBeCreated[name] = relatedPropertiesInfo.additionalProperties[name];
 				});
@@ -1404,13 +1414,13 @@ export const getColumnsFromEntityType = function(
  * @param {string} fullPropertyPath The full path to the target property
  * @param {string} relativePath The relative path to the target property based on the context
  * @param {boolean} useDataFieldPrefix Should be prefixed with "DataField::", else it will be prefixed with "Property::"
- * @param {boolean} availableForAdaptation Decides whether column should be available for adaptation
- * @param {string[]} nonSortableColumns The array of all non sortable column names
+ * @param {boolean} availableForAdaptation Decides whether the column should be available for adaptation
+ * @param {string[]} nonSortableColumns The array of all non-sortable column names
  * @param {AggregationHelper} aggregationHelper The aggregationHelper for the entity
  * @param {ConverterContext} converterContext The converter context
  * @returns {AnnotationTableColumn} The annotation column definition
  */
-const getColumnDefinitionFromProperty = function(
+const getColumnDefinitionFromProperty = function (
 	property: Property,
 	fullPropertyPath: string,
 	relativePath: string,
@@ -1431,6 +1441,9 @@ const getColumnDefinitionFromProperty = function(
 	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 semanticKeys: SemanticKey = converterContext.getAnnotationsByTerm("Common", CommonAnnotationTerms.SemanticKey, [
+		converterContext.getEntityType()
+	])[0];
 	const oTypeConfig = !isDataPointFakeProperty
 		? {
 				className: property.type || dataType,
@@ -1438,7 +1451,7 @@ const getColumnDefinitionFromProperty = function(
 				oConstraints: propertyTypeConfig.constraints
 		  }
 		: undefined;
-	const exportSettings = isDataPointFakeProperty
+	const exportSettings: any = isDataPointFakeProperty
 		? {
 				template: getTargetValueOnDataPoint(property)
 		  }
@@ -1451,6 +1464,17 @@ const getColumnDefinitionFromProperty = function(
 				falseValue: property.type === "Edm.Boolean" ? "No" : undefined
 		  };
 
+	if (!isDataPointFakeProperty) {
+		const oUnitProperty = getAssociatedCurrencyProperty(property) || getAssociatedUnitProperty(property);
+		const sUnitText = property?.annotations?.Measures?.ISOCurrency || property?.annotations?.Measures?.Unit;
+		if (oUnitProperty) {
+			exportSettings.unitProperty = oUnitProperty.name;
+			exportSettings.type = "Currency"; // Force to a currency because there's a unitProperty (otherwise the value isn't properly formatted when exported)
+		} else if (sUnitText) {
+			exportSettings.unit = `${sUnitText}`;
+		}
+	}
+
 	const oColumn: any = {
 		key: key,
 		isGroupable: !isDataPointFakeProperty && !isHidden ? aggregationHelper.isPropertyGroupable(property) : false,
@@ -1473,7 +1497,8 @@ const getColumnDefinitionFromProperty = function(
 		exportSettings: exportSettings,
 		caseSensitive: isFilteringCaseSensitive(converterContext),
 		typeConfig: oTypeConfig,
-		visualSettings: isDataPointFakeProperty ? { widthCalculation: null } : undefined
+		visualSettings: isDataPointFakeProperty ? { widthCalculation: null } : undefined,
+		importance: getImportance((property as any).annotations?.UI?.DataFieldDefault, semanticKeys)
 	};
 	const sTooltip = _getTooltip(property);
 	if (sTooltip) {
@@ -1490,14 +1515,13 @@ const getColumnDefinitionFromProperty = function(
  * @returns {boolean} True for valid columns, false for invalid columns
  * @private
  */
-const _isValidColumn = function(dataField: DataFieldAbstractTypes) {
+const _isValidColumn = function (dataField: DataFieldAbstractTypes) {
 	switch (dataField.$Type) {
 		case UIAnnotationTypes.DataFieldForAction:
 		case UIAnnotationTypes.DataFieldForIntentBasedNavigation:
 			return !!dataField.Inline;
 		case UIAnnotationTypes.DataFieldWithAction:
 		case UIAnnotationTypes.DataFieldWithIntentBasedNavigation:
-			return false;
 		case UIAnnotationTypes.DataField:
 		case UIAnnotationTypes.DataFieldWithUrl:
 		case UIAnnotationTypes.DataFieldForAnnotation:
@@ -1515,11 +1539,12 @@ const _isValidColumn = function(dataField: DataFieldAbstractTypes) {
  * 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 {object} [formatOptions] FormatOptions optional.
+ * @param {boolean} formatOptions.isAnalytics This flag is 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(
+export const _getVisibleExpression = function (
 	dataFieldModelPath: DataModelObjectPath,
 	formatOptions?: any,
 	returnExpression: boolean = false
@@ -1562,17 +1587,18 @@ export const _getVisibleExpression = function(
 			or(not(isAnalyticalGroupHeaderExpanded), isAnalyticalLeaf)
 		]
 	);
-	return returnExpression ? (expression as BindingExpression<string>) : compileBinding(expression);
+	return returnExpression ? (expression as any 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.
+ * @param {object} fieldFormatOptions FormatOptions optional.
+ * @param {boolean} fieldFormatOptions.isAnalytics This flag is used to check if the analytic table has GroupHeader expanded.
  * @returns {BindingExpression<string>} Compile binding of field group expressions.
  * @private
  */
-const _getFieldGroupHiddenExpressions = function(
+const _getFieldGroupHiddenExpressions = function (
 	dataFieldGroup: DataFieldAbstractTypes,
 	fieldFormatOptions: any
 ): BindingExpression<string> | undefined {
@@ -1587,7 +1613,7 @@ const _getFieldGroupHiddenExpressions = function(
 			);
 		});
 		return compileBinding(
-			ifElse(or(...(aFieldGroupHiddenExpressions as ExpressionOrPrimitive<boolean>[])), constant(true), constant(false))
+			ifElse(or(...(aFieldGroupHiddenExpressions as any as ExpressionOrPrimitive<boolean>[])), constant(true), constant(false))
 		);
 	} else {
 		return undefined;
@@ -1601,7 +1627,7 @@ const _getFieldGroupHiddenExpressions = function(
  * @returns {string} Label of the property or DataField
  * @private
  */
-const _getLabel = function(property: DataFieldAbstractTypes | Property, isGroup: boolean = false): string | undefined {
+const _getLabel = function (property: DataFieldAbstractTypes | Property, isGroup: boolean = false): string | undefined {
 	if (!property) {
 		return undefined;
 	}
@@ -1631,7 +1657,7 @@ const _getLabel = function(property: DataFieldAbstractTypes | Property, isGroup:
 	}
 };
 
-const _getTooltip = function(source: DataFieldAbstractTypes | Property): string | undefined {
+const _getTooltip = function (source: DataFieldAbstractTypes | Property): string | undefined {
 	if (!source) {
 		return undefined;
 	}
@@ -1653,7 +1679,12 @@ const _getTooltip = function(source: DataFieldAbstractTypes | Property): string
 		return undefined;
 	}
 };
-
+export function getRowStatusVisibility(): Expression<boolean> {
+	return formatResult(
+		[bindingExpression(`semanticKeyHasDraftIndicator`, "internal"), bindingExpression(`filteredMessages`, "internal")],
+		tableFormatters.getErrorStatusTextVisibilityFormatter
+	);
+}
 /**
  * Creates a PropertyInfo for each identified property consumed by a LineItem.
  *
@@ -1664,7 +1695,7 @@ const _getTooltip = function(source: DataFieldAbstractTypes | Property): string
  * @param entityType The entity type for the LineItem
  * @returns {AnnotationTableColumn[]} The array of columns created.
  */
-const _createRelatedColumns = function(
+const _createRelatedColumns = function (
 	columnsToBeCreated: Record<string, Property>,
 	existingColumns: AnnotationTableColumn[],
 	nonSortableColumns: string[],
@@ -1675,11 +1706,11 @@ const _createRelatedColumns = function(
 	const relatedPropertyNameMap: Record<string, string> = {};
 	const aggregationHelper = new AggregationHelper(entityType, converterContext);
 
-	Object.keys(columnsToBeCreated).forEach(name => {
+	Object.keys(columnsToBeCreated).forEach((name) => {
 		const property = columnsToBeCreated[name],
 			annotationPath = converterContext.getAbsoluteAnnotationPath(name),
 			// Check whether the related column already exists.
-			relatedColumn = existingColumns.find(column => column.name === name);
+			relatedColumn = existingColumns.find((column) => column.name === name);
 		if (relatedColumn === undefined) {
 			// Case 1: Key contains DataField prefix to ensure all property columns have the same key format.
 			// New created property column is set to hidden.
@@ -1706,7 +1737,7 @@ const _createRelatedColumns = function(
 			const newName = "Property::" + name;
 
 			// Checking whether the related property column has already been created in a previous iteration.
-			if (!existingColumns.some(column => column.name === newName)) {
+			if (!existingColumns.some((column) => column.name === newName)) {
 				// Create a new property column with 'Property::' prefix,
 				// Set it to hidden as it is only consumed by Complex property infos.
 				relatedColumns.push(
@@ -1728,10 +1759,10 @@ const _createRelatedColumns = function(
 
 	// The property 'name' has been prefixed with 'Property::' for uniqueness.
 	// Update the same in other propertyInfos[] references which point to this property.
-	existingColumns.forEach(column => {
-		column.propertyInfos = column.propertyInfos?.map(propertyInfo => relatedPropertyNameMap[propertyInfo] ?? propertyInfo);
+	existingColumns.forEach((column) => {
+		column.propertyInfos = column.propertyInfos?.map((propertyInfo) => relatedPropertyNameMap[propertyInfo] ?? propertyInfo);
 		column.additionalPropertyInfos = column.additionalPropertyInfos?.map(
-			propertyInfo => relatedPropertyNameMap[propertyInfo] ?? propertyInfo
+			(propertyInfo) => relatedPropertyNameMap[propertyInfo] ?? propertyInfo
 		);
 	});
 
@@ -1747,7 +1778,7 @@ const _createRelatedColumns = function(
  * @returns {string} The name of annotation columns
  * @private
  */
-const _getAnnotationColumnName = function(dataField: DataFieldAbstractTypes) {
+const _getAnnotationColumnName = function (dataField: DataFieldAbstractTypes) {
 	// This is needed as we have flexibility changes already that we have to check against
 	if (isDataFieldTypes(dataField)) {
 		return dataField.Value?.path;
@@ -1767,12 +1798,12 @@ const _getAnnotationColumnName = function(dataField: DataFieldAbstractTypes) {
  * @returns {boolean} `showDataFieldsLabel` value from the manifest
  * @private
  */
-const _getShowDataFieldsLabel = function(fieldGroupName: string, visualizationPath: string, converterContext: ConverterContext): boolean {
+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) {
+		!!aColumnKeys.find(function (key: string) {
 			return key === fieldGroupName && oColumns[key].showDataFieldsLabel;
 		})
 	);
@@ -1783,13 +1814,15 @@ const _getShowDataFieldsLabel = function(fieldGroupName: string, visualizationPa
  * @param dataField The `DataField` being processed.
  * @returns {string} The relative path
  */
-const _getRelativePath = function(dataField: DataFieldAbstractTypes): string {
+const _getRelativePath = function (dataField: DataFieldAbstractTypes): string {
 	let relativePath: string = "";
 
 	switch (dataField.$Type) {
 		case UIAnnotationTypes.DataField:
 		case UIAnnotationTypes.DataFieldWithNavigationPath:
 		case UIAnnotationTypes.DataFieldWithUrl:
+		case UIAnnotationTypes.DataFieldWithIntentBasedNavigation:
+		case UIAnnotationTypes.DataFieldWithAction:
 			relativePath = (dataField as DataField)?.Value?.path;
 			break;
 
@@ -1806,7 +1839,7 @@ const _getRelativePath = function(dataField: DataFieldAbstractTypes): string {
 	return relativePath;
 };
 
-const _sliceAtSlash = function(path: string, isLastSlash: boolean, isLastPart: boolean) {
+const _sliceAtSlash = function (path: string, isLastSlash: boolean, isLastPart: boolean) {
 	const iSlashIndex = isLastSlash ? path.lastIndexOf("/") : path.indexOf("/");
 
 	if (iSlashIndex === -1) {
@@ -1823,7 +1856,7 @@ const _sliceAtSlash = function(path: string, isLastSlash: boolean, isLastPart: b
  * @param nonSortableColumns Collection of non-sortable column names as per annotation
  * @returns {boolean} True if the column is sortable
  */
-const _isColumnSortable = function(dataField: DataFieldAbstractTypes, propertyPath: string, nonSortableColumns: string[]): boolean {
+const _isColumnSortable = function (dataField: DataFieldAbstractTypes, propertyPath: string, nonSortableColumns: string[]): boolean {
 	let isSortable: boolean = false;
 	if (nonSortableColumns.indexOf(propertyPath) === -1) {
 		// Column is not marked as non-sortable via annotation
@@ -1849,7 +1882,7 @@ const _isColumnSortable = function(dataField: DataFieldAbstractTypes, propertyPa
  * @param {ConverterContext} converterContext The instance of the converter context
  * @returns {boolean} Returns 'false' if FilterFunctions annotation supports 'tolower', else 'true'
  */
-export const isFilteringCaseSensitive = function(converterContext: ConverterContext): boolean {
+export const isFilteringCaseSensitive = function (converterContext: ConverterContext): boolean {
 	const filterFunctions: FilterFunctions | undefined =
 		converterContext.getEntitySet()?.annotations?.Capabilities?.FilterFunctions ||
 		converterContext.getEntityContainer().annotations?.Capabilities?.FilterFunctions;
@@ -1867,34 +1900,197 @@ function getDefaultFormatOptionsForTable(): FormatOptionsType {
 	};
 }
 
+function _findSemanticKeyValues(semanticKeys: any[], name: string): any {
+	const aSemanticKeyValues: string[] = [];
+	let bSemanticKeyFound = false;
+	for (let i = 0; i < semanticKeys.length; i++) {
+		aSemanticKeyValues.push(semanticKeys[i].value);
+		if (semanticKeys[i].value === name) {
+			bSemanticKeyFound = true;
+		}
+	}
+	return {
+		values: aSemanticKeyValues,
+		semanticKeyFound: bSemanticKeyFound
+	};
+}
+
+function _findProperties(semanticKeyValues: any[], fieldGroupProperties: any[]) {
+	let semanticKeyHasPropertyInFieldGroup = false;
+	let sPropertyPath;
+	if (semanticKeyValues && semanticKeyValues.length >= 1 && fieldGroupProperties && fieldGroupProperties.length >= 1) {
+		for (let i = 0; i < semanticKeyValues.length; i++) {
+			if ([semanticKeyValues[i]].some((tmp) => fieldGroupProperties.indexOf(tmp) >= 0)) {
+				semanticKeyHasPropertyInFieldGroup = true;
+				sPropertyPath = semanticKeyValues[i];
+				break;
+			}
+		}
+	}
+	return {
+		semanticKeyHasPropertyInFieldGroup: semanticKeyHasPropertyInFieldGroup,
+		fieldGroupPropertyPath: sPropertyPath
+	};
+}
+
+function _findSemanticKeyValuesInFieldGroup(dataFieldGroup: DataFieldAbstractTypes | null, semanticKeyValues: []): any {
+	const aProperties: any[] = [];
+	let _propertiesFound: { semanticKeyHasPropertyInFieldGroup: boolean; fieldGroupPropertyPath: any } = {
+		semanticKeyHasPropertyInFieldGroup: false,
+		fieldGroupPropertyPath: undefined
+	};
+	if (
+		dataFieldGroup &&
+		dataFieldGroup.$Type === UIAnnotationTypes.DataFieldForAnnotation &&
+		dataFieldGroup.Target?.$target?.$Type === UIAnnotationTypes.FieldGroupType
+	) {
+		dataFieldGroup.Target.$target.Data?.forEach((innerDataField: DataFieldAbstractTypes) => {
+			if (
+				(innerDataField.$Type === UIAnnotationTypes.DataField || innerDataField.$Type === UIAnnotationTypes.DataFieldWithUrl) &&
+				innerDataField.Value
+			) {
+				aProperties.push(innerDataField.Value.path);
+			}
+			_propertiesFound = _findProperties(semanticKeyValues, aProperties);
+		});
+	}
+	return {
+		semanticKeyHasPropertyInFieldGroup: _propertiesFound.semanticKeyHasPropertyInFieldGroup,
+		propertyPath: _propertiesFound.fieldGroupPropertyPath
+	};
+}
+
 /**
  * Returns default format options with draftIndicator for a column.
  * @param name
  * @param semanticKeys
+ * @param isFieldGroupColumn
+ * @param dataFieldGroup
  * @returns {FormatOptionsType} Collection of format options with default values
  */
-function getDefaultDraftIndicatorForColumn(name: string, semanticKeys: any[]) {
-	let bSemanticKeyFound = false;
-	const aSemanticKeyValues: string[] = [];
+function getDefaultDraftIndicatorForColumn(
+	name: string,
+	semanticKeys: any[],
+	isFieldGroupColumn: boolean,
+	dataFieldGroup: DataFieldAbstractTypes | null
+) {
 	if (!semanticKeys) {
 		return {};
 	}
-	for (let i = 0; i < semanticKeys.length; i++) {
-		aSemanticKeyValues.push(semanticKeys[i].value);
-		if (semanticKeys[i].value === name) {
-			bSemanticKeyFound = true;
-		}
-	}
-	if (bSemanticKeyFound) {
+	const semanticKey = _findSemanticKeyValues(semanticKeys, name);
+	const semanticKeyInFieldGroup = _findSemanticKeyValuesInFieldGroup(dataFieldGroup, semanticKey.values);
+	if (semanticKey.semanticKeyFound) {
 		return {
 			hasDraftIndicator: true,
-			semantickeys: aSemanticKeyValues
+			semantickeys: semanticKey.values,
+			objectStatusTextVisibility: compileBinding(getRowStatusVisibility())
 		};
 	} else {
-		return {};
+		if (!semanticKeyInFieldGroup.semanticKeyHasPropertyInFieldGroup) {
+			return {};
+		} else {
+			// Semantic Key has a property in a FieldGroup
+			return {
+				FieldGroupDraftIndicatorPropertyPath: semanticKeyInFieldGroup.propertyPath,
+				FieldGroupName: name
+			};
+		}
+	}
+}
+
+function _getImpNumber(dataField: DataFieldTypes): number {
+	const importance = dataField?.annotations?.UI?.Importance as string;
+
+	if (importance && importance.includes("UI.ImportanceType/High")) {
+		return 3;
+	}
+	if (importance && importance.includes("UI.ImportanceType/Medium")) {
+		return 2;
+	}
+	if (importance && importance.includes("UI.ImportanceType/Low")) {
+		return 1;
+	}
+	return 0;
+}
+
+function _getDataFieldImportance(dataField: DataFieldTypes): Importance {
+	const importance = dataField?.annotations?.UI?.Importance as string;
+	return importance ? (importance.split("/")[1] as Importance) : Importance.None;
+}
+
+function _getMaxImportance(fields: DataFieldTypes[]): Importance {
+	if (fields && fields.length > 0) {
+		let maxImpNumber = -1;
+		let impNumber = -1;
+		let DataFieldWithMaxImportance;
+		for (const field of fields) {
+			impNumber = _getImpNumber(field);
+			if (impNumber > maxImpNumber) {
+				maxImpNumber = impNumber;
+				DataFieldWithMaxImportance = field;
+			}
+		}
+		return _getDataFieldImportance(DataFieldWithMaxImportance as DataFieldTypes);
 	}
+	return Importance.None;
 }
 
+/**
+ * Returns the importance value for a column.
+ *
+ * @param dataField
+ * @param semanticKeys
+ * @returns {Importance} The importance value
+ */
+export function getImportance(dataField: DataFieldAbstractTypes, semanticKeys: SemanticKey): Importance | undefined {
+	//Evaluate default Importance is not set explicitly
+	let fieldsWithImportance, mapSemanticKeys: any;
+	//Check if semanticKeys are defined at the EntitySet level
+	if (semanticKeys && semanticKeys.length > 0) {
+		mapSemanticKeys = semanticKeys.map(function (key) {
+			return key.value;
+		});
+	}
+	if (!dataField) {
+		return undefined;
+	}
+	if (dataField.$Type === UIAnnotationTypes.DataFieldForAnnotation) {
+		const fieldGroupData = (dataField as any).Target["$target"]["Data"] as FieldGroupType,
+			fieldGroupHasSemanticKey =
+				fieldGroupData &&
+				(fieldGroupData as any).some(function (fieldGroupDataField: DataFieldAbstractTypes) {
+					return (
+						(fieldGroupDataField as unknown as DataFieldTypes)?.Value?.path &&
+						fieldGroupDataField.$Type !== UIAnnotationTypes.DataFieldForAnnotation &&
+						mapSemanticKeys &&
+						mapSemanticKeys.includes((fieldGroupDataField as unknown as DataFieldTypes)?.Value?.path)
+					);
+				});
+		//If a FieldGroup contains a semanticKey, importance set to High
+		if (fieldGroupHasSemanticKey) {
+			return Importance.High;
+		} else {
+			//If the DataFieldForAnnotation has an Importance we take it
+			if (dataField?.annotations?.UI?.Importance) {
+				return _getDataFieldImportance(dataField as unknown as DataFieldTypes);
+			}
+			// else the highest importance (if any) is returned
+			fieldsWithImportance =
+				fieldGroupData &&
+				(fieldGroupData as any).filter(function (item: DataFieldTypes) {
+					return item?.annotations?.UI?.Importance;
+				});
+			return _getMaxImportance(fieldsWithImportance as DataFieldTypes[]);
+		}
+		//If the current field is a semanticKey, importance set to High
+	}
+	return (dataField as DataFieldTypes).Value &&
+		(dataField as DataFieldTypes)?.Value?.path &&
+		mapSemanticKeys &&
+		mapSemanticKeys.includes((dataField as DataFieldTypes).Value.path)
+		? Importance.High
+		: _getDataFieldImportance(dataField as unknown as DataFieldTypes);
+}
 /**
  * Returns line items from metadata annotations.
  *
@@ -1903,7 +2099,7 @@ function getDefaultDraftIndicatorForColumn(name: string, semanticKeys: any[]) {
  * @param {ConverterContext} converterContext The converter context
  * @returns {TableColumn[]} The columns from the annotations
  */
-const getColumnsFromAnnotations = function(
+const getColumnsFromAnnotations = function (
 	lineItemAnnotation: LineItem,
 	visualizationPath: string,
 	converterContext: ConverterContext
@@ -1914,11 +2110,11 @@ const getColumnsFromAnnotations = function(
 		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", [
+	const semanticKeys: SemanticKey = converterContext.getAnnotationsByTerm("Common", CommonAnnotationTerms.SemanticKey, [
 		converterContext.getEntityType()
 	])[0];
 	if (lineItemAnnotation) {
-		lineItemAnnotation.forEach(lineItem => {
+		lineItemAnnotation.forEach((lineItem) => {
 			if (!_isValidColumn(lineItem)) {
 				return;
 			}
@@ -1943,7 +2139,7 @@ const getColumnsFromAnnotations = function(
 			const sDateInputFormat: string | undefined = dataType === "Edm.Date" ? "YYYY-MM-DD" : undefined;
 			const formatOptions = {
 				...getDefaultFormatOptionsForTable(),
-				...getDefaultDraftIndicatorForColumn(name, semanticKeys)
+				...getDefaultDraftIndicatorForColumn(name, semanticKeys, isFieldGroupColumn, lineItem)
 			};
 			let fieldGroupHiddenExpressions: BindingExpression<string>;
 			if (
@@ -1952,7 +2148,7 @@ const getColumnsFromAnnotations = function(
 			) {
 				fieldGroupHiddenExpressions = _getFieldGroupHiddenExpressions(lineItem, formatOptions);
 			}
-			const exportSettings = {
+			const exportSettings: any = {
 				template: relatedPropertiesInfo.exportSettingsTemplate,
 				wrap: relatedPropertiesInfo.exportSettingsWrapping,
 				type: dataType ? _getExportDataType(dataType, relatedPropertyNames.length > 1) : undefined,
@@ -1961,6 +2157,13 @@ const getColumnsFromAnnotations = function(
 				trueValue: dataType === "Edm.Boolean" ? "Yes" : undefined,
 				falseValue: dataType === "Edm.Boolean" ? "No" : undefined
 			};
+
+			if (relatedPropertiesInfo.exportUnitName) {
+				exportSettings.unitProperty = relatedPropertiesInfo.exportUnitName;
+				exportSettings.type = "Currency"; // Force to a currency because there's a unitProperty (otherwise the value isn't properly formatted when exported)
+			} else if (relatedPropertiesInfo.exportUnitString) {
+				exportSettings.unit = relatedPropertiesInfo.exportUnitString;
+			}
 			const propertyTypeConfig = dataType && getTypeConfig(lineItem, dataType);
 			const oTypeConfig = propertyTypeConfig
 				? {
@@ -1977,7 +2180,7 @@ const getColumnsFromAnnotations = function(
 				// 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
+						excludeProperties: ["Property::" + relatedPropertiesInfo.visualSettingsToBeExcluded]
 					}
 				};
 			} else if (!dataType || !oTypeConfig) {
@@ -1988,7 +2191,7 @@ const getColumnsFromAnnotations = function(
 			// 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 { hasDraftIndicator } = getDefaultDraftIndicatorForColumn(name, semanticKeys, isFieldGroupColumn, lineItem);
 			const widthOverride =
 				(converterContext.getEntityType().annotations as any).FE?.Situations &&
 				hasDraftIndicator &&
@@ -2015,6 +2218,7 @@ const getColumnsFromAnnotations = function(
 				additionalPropertyInfos: additionalPropertyNames.length > 0 ? additionalPropertyNames : undefined,
 				exportSettings: exportSettings,
 				width: lineItem.annotations?.HTML5?.CssDefaults?.width || widthOverride || undefined,
+				importance: getImportance(lineItem as DataFieldTypes, semanticKeys),
 				isNavigable: true,
 				formatOptions: formatOptions,
 				exportContactProperty: relatedPropertiesInfo.exportSettingsContactProperty,
@@ -2030,12 +2234,12 @@ const getColumnsFromAnnotations = function(
 			annotationColumns.push(oColumn as AnnotationTableColumn);
 
 			// Collect information of related columns to be created.
-			relatedPropertyNames.forEach(name => {
+			relatedPropertyNames.forEach((name) => {
 				columnsToBeCreated[name] = relatedPropertiesInfo.properties[name];
 			});
 
 			// Create columns for additional properties identified for ALP use case.
-			additionalPropertyNames.forEach(name => {
+			additionalPropertyNames.forEach((name) => {
 				// Intentional overwrite as we require only one new PropertyInfo for a related Property.
 				columnsToBeCreated[name] = relatedPropertiesInfo.additionalProperties[name];
 			});
@@ -2069,7 +2273,7 @@ const getColumnsFromAnnotations = function(
  * @param entityType
  * @returns {string[]} The columns from the annotations
  */
-const _getPropertyNames = function(
+const _getPropertyNames = function (
 	properties: string[] | undefined,
 	annotationColumns: AnnotationTableColumn[],
 	converterContext: ConverterContext,
@@ -2077,8 +2281,8 @@ const _getPropertyNames = function(
 ): string[] | undefined {
 	let matchedProperties: string[] | undefined;
 	if (properties) {
-		matchedProperties = properties.map(function(propertyPath) {
-			const annotationColumn = annotationColumns.find(function(annotationColumn) {
+		matchedProperties = properties.map(function (propertyPath) {
+			const annotationColumn = annotationColumns.find(function (annotationColumn) {
 				return annotationColumn.relativePath === propertyPath && annotationColumn.propertyInfos === undefined;
 			});
 			if (annotationColumn) {
@@ -2100,9 +2304,9 @@ const _getPropertyNames = function(
 	return matchedProperties;
 };
 
-const _appendCustomTemplate = function(properties: string[]): string {
+const _appendCustomTemplate = function (properties: string[]): string {
 	return properties
-		.map(property => {
+		.map((property) => {
 			return `{${properties.indexOf(property)}}`;
 		})
 		.join(`${"\n"}`);
@@ -2119,7 +2323,7 @@ const _appendCustomTemplate = function(properties: string[]): string {
  * @param {boolean} isAnnotationColumn Whether the column, defined in manifest, corresponds to an existing annotation column.
  * @returns {any} Determined property value for the column
  */
-const _getManifestOrDefaultValue = function(property: any, defaultValue: any, isAnnotationColumn: boolean): any {
+const _getManifestOrDefaultValue = function (property: any, defaultValue: any, isAnnotationColumn: boolean): any {
 	if (property === undefined) {
 		// If annotation column has no property defined in manifest,
 		// do not overwrite it with manifest column's default value.
@@ -2138,7 +2342,7 @@ const _getManifestOrDefaultValue = function(property: any, defaultValue: any, is
  * @param navigationSettings
  * @returns {Record<string, CustomColumn>} The columns from the manifest
  */
-const getColumnsFromManifest = function(
+const getColumnsFromManifest = function (
 	columns: Record<string, ManifestTableColumn>,
 	annotationColumns: AnnotationTableColumn[],
 	converterContext: ConverterContext,
@@ -2150,7 +2354,7 @@ const getColumnsFromManifest = function(
 	for (const key in columns) {
 		const manifestColumn = columns[key];
 		// To identify the annotation column property overwrite via manifest use-case.
-		const isAnnotationColumn = annotationColumns.some(column => column.key === key);
+		const isAnnotationColumn = annotationColumns.some((column) => column.key === key);
 		KeyHelper.validateKey(key);
 		const propertyInfos: string[] | undefined = _getPropertyNames(
 			manifestColumn.properties,
@@ -2158,7 +2362,7 @@ const getColumnsFromManifest = function(
 			converterContext,
 			entityType
 		);
-		if (!manifestColumn?.template && !isAnnotationColumn) {
+		if (!manifestColumn?.template && manifestColumn?.type !== "Slot" && !isAnnotationColumn) {
 			const Message = "The annotation column '" + key + "' referenced in the manifest is not found";
 			converterContext
 				.getDiagnostics()
@@ -2176,6 +2380,7 @@ const getColumnsFromManifest = function(
 				name: "CustomColumn::" + key,
 				header: manifestColumn.header,
 				width: manifestColumn.width || undefined,
+				importance: _getManifestOrDefaultValue(manifestColumn?.importance, Importance.None, isAnnotationColumn),
 				horizontalAlign: _getManifestOrDefaultValue(manifestColumn?.horizontalAlign, HorizontalAlign.Begin, isAnnotationColumn),
 				type: manifestColumn.type === "Slot" ? ColumnType.Slot : ColumnType.Default,
 				availability: _getManifestOrDefaultValue(manifestColumn?.availability, AvailabilityType.Default, isAnnotationColumn),
@@ -2188,10 +2393,14 @@ const getColumnsFromManifest = function(
 				settings: manifestColumn.settings,
 				sortable: false,
 				propertyInfos: propertyInfos,
-				formatOptions: {
-					...getDefaultFormatOptionsForTable(),
-					...manifestColumn.formatOptions
-				},
+				formatOptions: _getManifestOrDefaultValue(
+					manifestColumn.formatOptions,
+					{
+						...getDefaultFormatOptionsForTable(),
+						...manifestColumn.formatOptions
+					},
+					isAnnotationColumn
+				),
 				exportSettings: {
 					template: propertyInfos ? _appendCustomTemplate(propertyInfos) : undefined,
 					fieldLabel: propertyInfos ? manifestColumn.header : undefined,
@@ -2243,12 +2452,17 @@ export function getP13nMode(
 		// No personalization configured in manifest.
 		aPersonalization.push("Sort");
 		aPersonalization.push("Column");
-		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
+		if (converterContext.getTemplateType() === TemplateType.ListReport) {
+			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");
+			}
+		} else {
 			aPersonalization.push("Filter");
 		}
+
 		if (bAnalyticalTable) {
 			aPersonalization.push("Group");
 			aPersonalization.push("Aggregate");
@@ -2297,7 +2511,7 @@ function getSortConditions(
 		const conditions = {
 			sorters: sorters
 		};
-		presentationVariantAnnotation.SortOrder.forEach(condition => {
+		presentationVariantAnnotation.SortOrder.forEach((condition) => {
 			const conditionProperty = condition.Property;
 			if (conditionProperty && nonSortableProperties.indexOf(conditionProperty.$target?.name) === -1) {
 				const infoName = convertPropertyPathsToInfoNames([conditionProperty], columns)[0];
@@ -2324,9 +2538,9 @@ function getSortConditions(
 
 function convertPropertyPathsToInfoNames(paths: PropertyPath[], columns: TableColumn[]): string[] {
 	const infoNames: string[] = [];
-	paths.forEach(currentPath => {
+	paths.forEach((currentPath) => {
 		if (currentPath?.$target?.name) {
-			const propertyInfo = columns.find(column => {
+			const propertyInfo = columns.find((column) => {
 				const annotationColumn = column as AnnotationTableColumn;
 				return !annotationColumn.propertyInfos && annotationColumn.relativePath === currentPath?.$target?.name;
 			});
@@ -2353,7 +2567,7 @@ function getGroupConditions(
 	let groupConditions: string | undefined;
 	if (presentationVariantAnnotation?.GroupBy) {
 		const aGroupBy = presentationVariantAnnotation.GroupBy as PropertyPath[];
-		const aGroupLevels = convertPropertyPathsToInfoNames(aGroupBy, columns).map(infoName => {
+		const aGroupLevels = convertPropertyPathsToInfoNames(aGroupBy, columns).map((infoName) => {
 			return { name: infoName };
 		});
 
@@ -2377,7 +2591,7 @@ function getAggregateConditions(
 	if (presentationVariantAnnotation?.Total) {
 		const aTotals = presentationVariantAnnotation.Total as PropertyPath[];
 		const aggregates: Record<string, object> = {};
-		convertPropertyPathsToInfoNames(aTotals, columns).forEach(infoName => {
+		convertPropertyPathsToInfoNames(aTotals, columns).forEach((infoName) => {
 			aggregates[infoName] = {};
 		});
 
@@ -2407,9 +2621,10 @@ export function getTableAnnotationConfiguration(
 	const targetCapabilities = getCapabilityRestriction(converterContext);
 	const navigationTargetPath = getNavigationTargetPath(converterContext, navigationPropertyPath);
 	const navigationSettings = pageManifestSettings.getNavigationConfiguration(navigationTargetPath);
+	const creationBehaviour = _getCreationBehaviour(lineItemAnnotation, tableManifestConfiguration, converterContext, navigationSettings);
 	const standardActionsContext = generateStandardActionsContext(
 		converterContext,
-		navigationSettings,
+		creationBehaviour.mode as CreationMode,
 		tableManifestConfiguration,
 		viewConfiguration
 	);
@@ -2437,14 +2652,14 @@ export function getTableAnnotationConfiguration(
 		threshold = presentationVariantAnnotation.MaxItems.valueOf() as number;
 	}
 
-	const creationBehaviour = _getCreationBehaviour(lineItemAnnotation, tableManifestConfiguration, converterContext, navigationSettings);
 	const variantManagement: VariantManagementType = pageManifestSettings.getVariantManagement();
 	const isSearchable = isPathSearchable(converterContext.getDataModelObjectPath());
 	const standardActions = {
 		create: getStandardActionCreate(converterContext, standardActionsContext),
 		"delete": getStandardActionDelete(converterContext, standardActionsContext),
 		paste: getStandardActionPaste(converterContext, standardActionsContext, isInsertUpdateTemplated),
-		massEdit: getStandardActionMassEdit(converterContext, standardActionsContext)
+		massEdit: getStandardActionMassEdit(converterContext, standardActionsContext),
+		creationRow: getCreationRow(converterContext, standardActionsContext)
 	};
 
 	return {
@@ -2615,6 +2830,7 @@ function _getTableType(
 	}
 	return tableType;
 }
+
 function _getFilters(
 	tableSettings: TableManifestSettingsConfiguration,
 	quickFilterPaths: { annotationPath: string }[],
@@ -2687,10 +2903,11 @@ export function getTableManifestConfiguration(
 	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);
 	const tableType: TableType = _getTableType(tableSettings, aggregationHelper, converterContext);
+	const condensedTableLayout =
+		tableSettings.condensedTableLayout !== undefined && tableType !== "ResponsiveTable" ? tableSettings.condensedTableLayout : false;
 	const oConfiguration = {
 		createAtEnd: tableSettings.creationMode?.createAtEnd !== undefined ? tableSettings.creationMode?.createAtEnd : true,
 		creationMode: tableSettings.creationMode?.name || creationMode,