@sapui5/sap.fe.core 1.102.2 → 1.104.1

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

@@ -1,78 +1,63 @@
-import { EntityType, Property, TypeDefinition } from "@sap-ux/annotation-converter";
-import {
+import type { EntityType, EnumValue, PathAnnotationExpression, Property, PropertyPath, TypeDefinition } from "@sap-ux/vocabularies-types";
+import type { FilterFunctions } from "@sap-ux/vocabularies-types/vocabularies/Capabilities";
+import type { SemanticKey } from "@sap-ux/vocabularies-types/vocabularies/Common";
+import { CommonAnnotationTerms } from "@sap-ux/vocabularies-types/vocabularies/Common";
+import type {
 	CriticalityType,
 	DataField,
 	DataFieldAbstractTypes,
 	DataFieldForAction,
-	DataFieldForAnnotation,
 	DataFieldForIntentBasedNavigation,
 	DataFieldTypes,
 	DataPoint,
 	DataPointTypeTypes,
-	EnumValue,
 	FieldGroupType,
 	LineItem,
-	PathAnnotationExpression,
-	PresentationVariantTypeTypes,
-	PropertyPath,
+	PresentationVariantType,
 	SelectionVariantType,
-	SelectOptionType,
-	UIAnnotationTypes
-} from "@sap-ux/vocabularies-types";
-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";
+	SelectOptionType
+} from "@sap-ux/vocabularies-types/vocabularies/UI";
+import { UIAnnotationTypes } from "@sap-ux/vocabularies-types/vocabularies/UI";
+import type { ComplexPropertyInfo } from "sap/fe/core/converters/annotations/DataField";
 import {
 	collectRelatedProperties,
 	collectRelatedPropertiesRecursively,
-	ComplexPropertyInfo,
 	getDataFieldDataType,
 	getSemanticObjectPath,
 	isDataFieldAlwaysHidden,
 	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 type { AnnotationAction, BaseAction, CustomAction } from "sap/fe/core/converters/controls/Common/Action";
+import { 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 type { ConfigurableObject, CustomElement } from "sap/fe/core/converters/helpers/ConfigurableObject";
+import { 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 type { BindingToolkitExpression, CompiledBindingToolkitExpression } from "sap/fe/core/helpers/BindingToolkit";
 import {
 	and,
-	annotationExpression,
-	BindingExpression,
-	bindingExpression,
-	BindingExpressionExpression,
-	compileBinding,
+	compileExpression,
 	constant,
 	equal,
-	Expression,
-	ExpressionOrPrimitive,
 	formatResult,
+	getExpressionFromAnnotation,
 	ifElse,
 	isConstant,
+	isPathInModelExpression,
 	not,
 	or,
+	pathInModel,
 	resolveBindingString
-} from "sap/fe/core/helpers/BindingExpression";
+} from "sap/fe/core/helpers/BindingToolkit";
 import { replaceSpecialChars } from "sap/fe/core/helpers/StableIdHelper";
-import {
-	DataModelObjectPath,
-	getTargetObjectPath,
-	isPathDeletable,
-	isPathSearchable,
-	isPathUpdatable
-} from "sap/fe/core/templating/DataModelPathHelper";
-import { DisplayMode, EDM_TYPE_MAPPING, getDisplayMode } from "sap/fe/core/templating/DisplayModeFormatter";
+import type { DataModelObjectPath } from "sap/fe/core/templating/DataModelPathHelper";
+import { getTargetObjectPath, isPathDeletable, isPathSearchable, isPathUpdatable } from "sap/fe/core/templating/DataModelPathHelper";
+import type { DisplayMode } from "sap/fe/core/templating/DisplayModeFormatter";
+import { EDM_TYPE_MAPPING, getDisplayMode } from "sap/fe/core/templating/DisplayModeFormatter";
 import { getNonSortablePropertiesRestrictions } from "sap/fe/core/templating/EntitySetHelper";
 import {
 	getAssociatedCurrencyProperty,
@@ -82,30 +67,33 @@ import {
 	isPathExpression,
 	isProperty
 } from "sap/fe/core/templating/PropertyHelper";
-import ConverterContext from "../../ConverterContext";
+import type ConverterContext from "../../ConverterContext";
 import { AggregationHelper } from "../../helpers/Aggregation";
-import { TableID } from "../../helpers/ID";
-import {
-	ActionType,
-	AvailabilityType,
-	CreationMode,
+import { getTableID } from "../../helpers/ID";
+import type {
 	FormatOptionsType,
-	HorizontalAlign,
-	Importance,
 	ManifestTableColumn,
 	NavigationSettingsConfiguration,
 	NavigationTargetConfiguration,
-	SelectionMode,
 	TableColumnSettings,
 	TableManifestConfiguration,
 	TableManifestSettingsConfiguration,
+	ViewPathConfiguration
+} from "../../ManifestSettings";
+import {
+	ActionType,
+	AvailabilityType,
+	CreationMode,
+	HorizontalAlign,
+	Importance,
+	SelectionMode,
 	TemplateType,
 	VariantManagementType,
-	ViewPathConfiguration,
 	VisualizationType
 } from "../../ManifestSettings";
-import ManifestWrapper from "../../ManifestWrapper";
+import type ManifestWrapper from "../../ManifestWrapper";
 import { getMessageTypeFromCriticalityType } from "./Criticality";
+import type { StandardActionConfigType } from "./table/StandardActions";
 import {
 	generateStandardActionsContext,
 	getCreateVisibility,
@@ -119,8 +107,7 @@ import {
 	getStandardActionMassEdit,
 	getStandardActionPaste,
 	isDraftOrStickySupported,
-	isInDisplayMode,
-	StandardActionConfigType
+	isInDisplayMode
 } from "./table/StandardActions";
 
 export type TableAnnotationConfiguration = {
@@ -134,9 +121,9 @@ export type TableAnnotationConfiguration = {
 	row?: {
 		action?: string;
 		press?: string;
-		rowHighlighting: BindingExpression<MessageType>;
-		rowNavigated: BindingExpression<boolean>;
-		visible?: BindingExpression<boolean>;
+		rowHighlighting: CompiledBindingToolkitExpression;
+		rowNavigated: CompiledBindingToolkitExpression;
+		visible?: CompiledBindingToolkitExpression;
 	};
 	selectionMode: string | undefined;
 	standardActions: {
@@ -217,6 +204,7 @@ export type TableControlConfiguration = {
 	enableMassEdit: boolean | undefined;
 	enableAutoColumnWidth: boolean;
 	dataStateIndicatorFilter: string | undefined;
+	isCompactType?: boolean;
 };
 
 export type TableType = "GridTable" | "ResponsiveTable" | "AnalyticalTable";
@@ -257,7 +245,7 @@ export type AnnotationTableColumn = BaseTableColumn & {
 	tooltip?: string;
 	groupLabel?: string;
 	group?: string;
-	FieldGroupHiddenExpressions?: BindingExpression<string>;
+	FieldGroupHiddenExpressions?: CompiledBindingToolkitExpression;
 	showDataFieldsLabel?: boolean;
 	isKey?: boolean;
 	unit?: string;
@@ -338,11 +326,11 @@ type SorterType = {
 /**
  * Returns an array of all annotation-based and manifest-based table actions.
  *
- * @param {LineItem} lineItemAnnotation
- * @param {string} visualizationPath
- * @param {ConverterContext} converterContext
- * @param {NavigationSettingsConfiguration} navigationSettings
- * @returns {BaseAction} The complete table actions
+ * @param lineItemAnnotation
+ * @param visualizationPath
+ * @param converterContext
+ * @param navigationSettings
+ * @returns The complete table actions
  */
 export function getTableActions(
 	lineItemAnnotation: LineItem,
@@ -378,11 +366,11 @@ export function getTableActions(
  * Returns an array of all columns, annotation-based as well as manifest based.
  * They are sorted and some properties can be overwritten via the manifest (check out the keys that can be overwritten).
  *
- * @param {LineItem} lineItemAnnotation Collection of data fields for representation in a table or list
- * @param {string} visualizationPath
- * @param {ConverterContext} converterContext
- * @param {NavigationSettingsConfiguration} navigationSettings
- * @returns {TableColumn[]} Returns all table columns that should be available, regardless of templating or personalization or their origin
+ * @param lineItemAnnotation Collection of data fields for representation in a table or list
+ * @param visualizationPath
+ * @param converterContext
+ * @param navigationSettings
+ * @returns Returns all table columns that should be available, regardless of templating or personalization or their origin
  */
 export function getTableColumns(
 	lineItemAnnotation: LineItem,
@@ -482,9 +470,9 @@ export const getAggregateDefinitionsFromEntityType = function (
 				};
 				const aContextDefiningProperties: string[] = [];
 				aRawContextDefiningProperties.forEach((contextDefiningPropertyName) => {
-					const oColumn = findColumnFromPath(contextDefiningPropertyName);
-					if (oColumn) {
-						aContextDefiningProperties.push(oColumn.name);
+					const foundColumn = findColumnFromPath(contextDefiningPropertyName);
+					if (foundColumn) {
+						aContextDefiningProperties.push(foundColumn.name);
 					}
 				});
 
@@ -510,7 +498,7 @@ function updateTableVisualizationForAnalytics(
 	tableVisualization: TableVisualization,
 	entityType: EntityType,
 	converterContext: ConverterContext,
-	presentationVariantAnnotation?: PresentationVariantTypeTypes
+	presentationVariantAnnotation?: PresentationVariantType
 ) {
 	if (tableVisualization.control.type === "AnalyticalTable") {
 		const aggregatesDefinitions = getAggregateDefinitionsFromEntityType(entityType, tableVisualization.columns, converterContext),
@@ -630,7 +618,7 @@ function getSemanticKeysAndTitleInfo(converterContext: ConverterContext) {
 		?.path;
 	const semanticKeyAnnotations: any[] | undefined = converterContext.getAnnotationEntityType()?.annotations?.Common?.SemanticKey;
 
-	let semanticKeyColumns: string[] = [];
+	const semanticKeyColumns: string[] = [];
 	if (semanticKeyAnnotations) {
 		semanticKeyAnnotations.forEach(function (oColumn: any) {
 			semanticKeyColumns.push(oColumn.value);
@@ -644,7 +632,7 @@ export function createTableVisualization(
 	lineItemAnnotation: LineItem,
 	visualizationPath: string,
 	converterContext: ConverterContext,
-	presentationVariantAnnotation?: PresentationVariantTypeTypes,
+	presentationVariantAnnotation?: PresentationVariantType,
 	isCondensedTableLayoutCompliant?: boolean,
 	viewConfiguration?: ViewPathConfiguration
 ): TableVisualization {
@@ -719,7 +707,7 @@ export function createDefaultTableVisualization(converterContext: ConverterConte
  *
  * @param lineItemAnnotation The instance of the line item
  * @param converterContext The instance of the converter context
- * @returns {Record<string, any>} The record containing all action names and their corresponding Core.OperationAvailable property paths
+ * @returns The record containing all action names and their corresponding Core.OperationAvailable property paths
  */
 function getOperationAvailableMap(lineItemAnnotation: LineItem | undefined, converterContext: ConverterContext): Record<string, any> {
 	const operationAvailableMap: Record<string, any> = {};
@@ -740,14 +728,14 @@ function getOperationAvailableMap(lineItemAnnotation: LineItem | undefined, conv
 						addToMap(actionName, null);
 					} else if (actionTarget?.parameters?.length) {
 						const bindingParameterFullName = actionTarget.parameters[0].fullyQualifiedName,
-							targetExpression = annotationExpression(
+							targetExpression = getExpressionFromAnnotation(
 								actionTarget?.annotations?.Core?.OperationAvailable,
 								[],
 								undefined,
 								(path: string) => bindingContextPathVisitor(path, converterContext, bindingParameterFullName)
-							) as BindingExpressionExpression<string>;
+							);
 
-						if (targetExpression?.path) {
+						if (isPathInModelExpression(targetExpression)) {
 							addToMap(actionName, targetExpression.path);
 						} else if (actionTarget?.annotations?.Core?.OperationAvailable !== undefined) {
 							addToMap(actionName, targetExpression);
@@ -765,7 +753,7 @@ function getOperationAvailableMap(lineItemAnnotation: LineItem | undefined, conv
  * Gets updatable propertyPath for the current entityset if valid.
  *
  * @param converterContext The instance of the converter context
- * @returns {string} The updatable property for the rows
+ * @returns The updatable property for the rows
  */
 function getCurrentEntitySetUpdatablePath(converterContext: ConverterContext): string {
 	const restrictions = getRestrictions(converterContext);
@@ -780,9 +768,9 @@ function getCurrentEntitySetUpdatablePath(converterContext: ConverterContext): s
 /**
  * Method to retrieve all property paths assigned to the Core.OperationAvailable annotation.
  *
- * @param {Record<string, any>} operationAvailableMap The record consisting of actions and their Core.OperationAvailable property paths
- * @param {ConverterContext} converterContext The instance of the converter context
- * @returns {string} The CSV string of all property paths associated with the Core.OperationAvailable annotation
+ * @param operationAvailableMap The record consisting of actions and their Core.OperationAvailable property paths
+ * @param converterContext The instance of the converter context
+ * @returns The CSV string of all property paths associated with the Core.OperationAvailable annotation
  */
 function getOperationAvailableProperties(operationAvailableMap: Record<string, any>, converterContext: ConverterContext): string {
 	const properties = new Set();
@@ -826,8 +814,8 @@ function getUIHiddenExpForActionsRequiringContext(
 	currentEntityType: EntityType,
 	contextDataModelObjectPath: DataModelObjectPath,
 	isEntitySet: boolean
-): Expression<boolean>[] {
-	const aUiHiddenPathExpressions: Expression<boolean>[] = [];
+): BindingToolkitExpression<boolean>[] {
+	const aUiHiddenPathExpressions: BindingToolkitExpression<boolean>[] = [];
 	lineItemAnnotation.forEach((dataField) => {
 		// Check if the lineItem context is the same as that of the action:
 		if (
@@ -839,16 +827,7 @@ function getUIHiddenExpForActionsRequiringContext(
 				dataField?.Inline?.valueOf() !== true)
 		) {
 			if (typeof dataField.annotations?.UI?.Hidden?.valueOf() === "object") {
-				aUiHiddenPathExpressions.push(
-					equal(
-						getBindingExpFromContext(
-							dataField as DataFieldForAction | DataFieldForIntentBasedNavigation,
-							contextDataModelObjectPath,
-							isEntitySet
-						),
-						false
-					)
-				);
+				aUiHiddenPathExpressions.push(equal(getBindingExpFromContext(dataField, contextDataModelObjectPath, isEntitySet), false));
 			}
 		}
 	});
@@ -870,7 +849,7 @@ function getBindingExpFromContext(
 	source: DataFieldForAction | DataFieldForIntentBasedNavigation | CustomAction,
 	contextDataModelObjectPath: DataModelObjectPath,
 	isEntitySet: boolean
-): Expression<any> {
+): BindingToolkitExpression<any> {
 	let sExpression: any | undefined;
 	if (
 		(source as DataFieldForAction)?.$Type === UIAnnotationTypes.DataFieldForAction ||
@@ -898,13 +877,13 @@ function getBindingExpFromContext(
 				contextDataModelObjectPath?.targetObject?._type === "NavigationProperty" &&
 				contextDataModelObjectPath.targetObject.partner === sNavigationPath
 			) {
-				return bindingExpression(aSplitPath.slice(1).join("/"));
+				return pathInModel(aSplitPath.slice(1).join("/"));
 			} else {
 				return constant(true);
 			}
 			// In case there is no navigation property, if it's an entitySet, the expression binding has to be returned:
 		} else if (isEntitySet) {
-			return bindingExpression(sPath);
+			return pathInModel(sPath);
 			// otherwise the expression binding cannot be taken into account for the selection mode evaluation:
 		} else {
 			return constant(true);
@@ -919,7 +898,7 @@ function getBindingExpFromContext(
  *
  * @param lineItemAnnotation Collection of data fields for representation in a table or list
  * @param currentEntityType Current Entity Type
- * @returns {boolean} `true` if there is at least 1 action that meets the criteria
+ * @returns `true` if there is at least 1 action that meets the criteria
  */
 function hasBoundActionsAlwaysVisibleInToolBar(lineItemAnnotation: LineItem, currentEntityType: EntityType): boolean {
 	return lineItemAnnotation.some((dataField) => {
@@ -957,8 +936,8 @@ function hasCustomActionsAlwaysVisibleInToolBar(manifestActions: Record<string,
  * @param manifestActions The actions defined in the manifest
  * @returns Array<Expression<boolean>> All the visible path expressions of the actions that meet the criteria
  */
-function getVisibleExpForCustomActionsRequiringContext(manifestActions: Record<string, CustomAction>): Expression<boolean>[] {
-	const aVisiblePathExpressions: Expression<boolean>[] = [];
+function getVisibleExpForCustomActionsRequiringContext(manifestActions: Record<string, CustomAction>): BindingToolkitExpression<boolean>[] {
+	const aVisiblePathExpressions: BindingToolkitExpression<boolean>[] = [];
 	if (manifestActions) {
 		Object.keys(manifestActions).forEach((actionKey) => {
 			const action = manifestActions[actionKey];
@@ -982,7 +961,7 @@ function getVisibleExpForCustomActionsRequiringContext(manifestActions: Record<s
  * Evaluate if the path is statically deletable or updatable.
  *
  * @param converterContext
- * @returns {TableCapabilityRestriction} The table capabilities
+ * @returns The table capabilities
  */
 export function getCapabilityRestriction(converterContext: ConverterContext): TableCapabilityRestriction {
 	const isDeletable = isPathDeletable(converterContext.getDataModelObjectPath());
@@ -999,16 +978,16 @@ export function getSelectionMode(
 	converterContext: ConverterContext,
 	isEntitySet: boolean,
 	targetCapabilities: TableCapabilityRestriction,
-	deleteButtonVisibilityExpression?: Expression<boolean>,
-	massEditVisibilityExpression: Expression<boolean> = constant(false)
+	deleteButtonVisibilityExpression?: BindingToolkitExpression<boolean>,
+	massEditVisibilityExpression: BindingToolkitExpression<boolean> = constant(false)
 ): string | undefined {
 	if (!lineItemAnnotation) {
 		return SelectionMode.None;
 	}
 	const tableManifestSettings = converterContext.getManifestControlConfiguration(visualizationPath);
 	let selectionMode = tableManifestSettings.tableSettings?.selectionMode;
-	let aHiddenBindingExpressions: Expression<boolean>[] = [],
-		aVisibleBindingExpressions: Expression<boolean>[] = [];
+	let aHiddenBindingExpressions: BindingToolkitExpression<boolean>[] = [],
+		aVisibleBindingExpressions: BindingToolkitExpression<boolean>[] = [];
 	const manifestActions = getActionsFromManifest(
 		converterContext.getManifestControlConfiguration(visualizationPath).actions,
 		converterContext,
@@ -1019,14 +998,14 @@ export function getSelectionMode(
 	let isParentDeletable, parentEntitySetDeletable;
 	if (converterContext.getTemplateType() === TemplateType.ObjectPage) {
 		isParentDeletable = isPathDeletable(converterContext.getDataModelObjectPath());
-		parentEntitySetDeletable = isParentDeletable ? compileBinding(isParentDeletable, true) : isParentDeletable;
+		parentEntitySetDeletable = isParentDeletable ? compileExpression(isParentDeletable, true) : isParentDeletable;
 	}
 
 	const bMassEditEnabled: boolean = !isConstant(massEditVisibilityExpression) || massEditVisibilityExpression.value !== false;
 	if (selectionMode && selectionMode === SelectionMode.None && deleteButtonVisibilityExpression) {
 		if (converterContext.getTemplateType() === TemplateType.ObjectPage && bMassEditEnabled) {
 			// Mass Edit in OP is enabled only in edit mode.
-			return compileBinding(
+			return compileExpression(
 				ifElse(
 					and(UI.IsEditable, massEditVisibilityExpression),
 					constant("Multi"),
@@ -1037,7 +1016,7 @@ export function getSelectionMode(
 			return SelectionMode.Multi;
 		}
 
-		return compileBinding(ifElse(deleteButtonVisibilityExpression, constant("Multi"), constant("None")));
+		return compileExpression(ifElse(deleteButtonVisibilityExpression, constant("Multi"), constant("None")));
 	}
 	if (!selectionMode || selectionMode === SelectionMode.Auto) {
 		selectionMode = SelectionMode.Multi;
@@ -1075,7 +1054,7 @@ export function getSelectionMode(
 					deleteButtonVisibilityExpression || true, // default delete visibility as true
 					massEditVisibilityExpression
 				);
-				return compileBinding(
+				return compileExpression(
 					ifElse(and(UI.IsEditable, buttonVisibilityExpression), constant(selectionMode), constant(SelectionMode.None))
 				);
 			} else {
@@ -1086,7 +1065,7 @@ export function getSelectionMode(
 			// example: LR scenario
 			return selectionMode;
 		} else if (targetCapabilities.isDeletable && deleteButtonVisibilityExpression) {
-			return compileBinding(ifElse(deleteButtonVisibilityExpression, constant(selectionMode), constant("None")));
+			return compileExpression(ifElse(deleteButtonVisibilityExpression, constant(selectionMode), constant("None")));
 			// EntitySet not deletable:
 		} else {
 			return SelectionMode.None;
@@ -1101,7 +1080,7 @@ export function getSelectionMode(
 				massEditVisibilityExpression,
 				constant(true)
 			);
-			return compileBinding(
+			return compileExpression(
 				ifElse(
 					and(UI.IsEditable, editModebuttonVisibilityExpression),
 					constant(selectionMode),
@@ -1113,7 +1092,7 @@ export function getSelectionMode(
 				)
 			);
 		} else {
-			return compileBinding(
+			return compileExpression(
 				ifElse(
 					or(...aHiddenBindingExpressions.concat(aVisibleBindingExpressions)),
 					constant(selectionMode),
@@ -1127,7 +1106,7 @@ export function getSelectionMode(
 		return selectionMode;
 		//EntitySet not deletable:
 	} else {
-		return compileBinding(
+		return compileExpression(
 			ifElse(
 				or(...aHiddenBindingExpressions.concat(aVisibleBindingExpressions), massEditVisibilityExpression),
 				constant(selectionMode),
@@ -1143,7 +1122,7 @@ export function getSelectionMode(
  * @param lineItemAnnotation
  * @param visualizationPath
  * @param converterContext
- * @returns {Record<BaseAction, BaseAction>} The table annotation actions
+ * @returns The table annotation actions
  */
 function getTableAnnotationActions(lineItemAnnotation: LineItem, visualizationPath: string, converterContext: ConverterContext) {
 	const tableActions: BaseAction[] = [];
@@ -1164,10 +1143,10 @@ function getTableAnnotationActions(lineItemAnnotation: LineItem, visualizationPa
 							type: ActionType.DataFieldForAction,
 							annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
 							key: key,
-							visible: compileBinding(
+							visible: compileExpression(
 								not(
 									equal(
-										annotationExpression(
+										getExpressionFromAnnotation(
 											dataField.annotations?.UI?.Hidden,
 											[],
 											undefined,
@@ -1186,10 +1165,10 @@ function getTableAnnotationActions(lineItemAnnotation: LineItem, visualizationPa
 							type: ActionType.DataFieldForIntentBasedNavigation,
 							annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
 							key: key,
-							visible: compileBinding(
+							visible: compileExpression(
 								not(
 									equal(
-										annotationExpression(
+										getExpressionFromAnnotation(
 											dataField.annotations?.UI?.Hidden,
 											[],
 											undefined,
@@ -1225,11 +1204,11 @@ function getHighlightRowBinding(
 	criticalityAnnotation: PathAnnotationExpression<CriticalityType> | EnumValue<CriticalityType> | undefined,
 	isDraftRoot: boolean,
 	targetEntityType?: EntityType
-): Expression<MessageType> {
-	let defaultHighlightRowDefinition: MessageType | Expression<MessageType> = MessageType.None;
+): BindingToolkitExpression<MessageType> {
+	let defaultHighlightRowDefinition: MessageType | BindingToolkitExpression<MessageType> = MessageType.None;
 	if (criticalityAnnotation) {
 		if (typeof criticalityAnnotation === "object") {
-			defaultHighlightRowDefinition = annotationExpression(criticalityAnnotation) as Expression<MessageType>;
+			defaultHighlightRowDefinition = getExpressionFromAnnotation(criticalityAnnotation) as BindingToolkitExpression<MessageType>;
 		} else {
 			// Enum Value so we get the corresponding static part
 			defaultHighlightRowDefinition = getMessageTypeFromCriticalityType(criticalityAnnotation);
@@ -1239,14 +1218,14 @@ function getHighlightRowBinding(
 	const aMissingKeys: any[] = [];
 	targetEntityType?.keys.forEach((key: any) => {
 		if (key.name !== "IsActiveEntity") {
-			aMissingKeys.push(bindingExpression(key.name, undefined));
+			aMissingKeys.push(pathInModel(key.name, undefined));
 		}
 	});
 
 	return formatResult(
 		[
 			defaultHighlightRowDefinition,
-			bindingExpression(`filteredMessages`, "internal"),
+			pathInModel(`filteredMessages`, "internal"),
 			isDraftRoot && Entity.HasActive,
 			isDraftRoot && Entity.IsActive,
 			`${isDraftRoot}`,
@@ -1322,7 +1301,7 @@ const _getRowConfigurationProperty = function (
 	targetPath: string
 ) {
 	let pressProperty, navigationTarget;
-	let criticalityProperty: ExpressionOrPrimitive<MessageType> = MessageType.None;
+	let criticalityProperty: BindingToolkitExpression<MessageType> = constant(MessageType.None);
 	const targetEntityType = converterContext.getEntityType();
 	if (navigationSettings && lineItemAnnotation) {
 		navigationTarget = navigationSettings.display?.target || navigationSettings.detail?.outbound;
@@ -1351,17 +1330,17 @@ const _getRowConfigurationProperty = function (
 			}
 		}
 	}
-	const rowNavigatedExpression: Expression<boolean> = formatResult(
-		[bindingExpression("/deepestPath", "internal")],
+	const rowNavigatedExpression: BindingToolkitExpression<boolean> = formatResult(
+		[pathInModel("/deepestPath", "internal")],
 		tableFormatters.navigatedRow,
 		targetEntityType
 	);
 	return {
 		press: pressProperty,
 		action: pressProperty ? "Navigation" : undefined,
-		rowHighlighting: compileBinding(criticalityProperty),
-		rowNavigated: compileBinding(rowNavigatedExpression),
-		visible: compileBinding(not(UI.IsInactive))
+		rowHighlighting: compileExpression(criticalityProperty),
+		rowNavigated: compileExpression(rowNavigatedExpression),
+		visible: compileExpression(not(UI.IsInactive))
 	};
 };
 
@@ -1374,7 +1353,7 @@ const _getRowConfigurationProperty = function (
  * @param nonSortableColumns The array of all non sortable column names.
  * @param converterContext The converter context.
  * @param tableType The table type.
- * @returns {AnnotationTableColumn[]} The column from the entityType
+ * @returns The column from the entityType
  */
 export const getColumnsFromEntityType = function (
 	columnsToBeCreated: Record<string, Property>,
@@ -1468,15 +1447,16 @@ export const getColumnsFromEntityType = function (
 
 /**
  * Create a column definition from a property.
- * @param {Property} property Entity type property for which the column is created
- * @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 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
+ *
+ * @param property Entity type property for which the column is created
+ * @param fullPropertyPath The full path to the target property
+ * @param relativePath The relative path to the target property based on the context
+ * @param useDataFieldPrefix Should be prefixed with "DataField::", else it will be prefixed with "Property::"
+ * @param availableForAdaptation Decides whether the column should be available for adaptation
+ * @param nonSortableColumns The array of all non-sortable column names
+ * @param aggregationHelper The aggregationHelper for the entity
+ * @param converterContext The converter context
+ * @returns The annotation column definition
  */
 const getColumnDefinitionFromProperty = function (
 	property: Property,
@@ -1488,7 +1468,7 @@ const getColumnDefinitionFromProperty = function (
 	aggregationHelper: AggregationHelper,
 	converterContext: ConverterContext
 ): AnnotationTableColumn {
-	const name = useDataFieldPrefix ? relativePath : "Property::" + relativePath;
+	const name = useDataFieldPrefix ? relativePath : `Property::${relativePath}`;
 	const key = (useDataFieldPrefix ? "DataField::" : "Property::") + replaceSpecialChars(relativePath);
 	const semanticObjectAnnotationPath = getSemanticObjectPath(converterContext, property);
 	const isHidden = property.annotations?.UI?.Hidden?.valueOf() === true;
@@ -1575,8 +1555,8 @@ const getColumnDefinitionFromProperty = function (
 /**
  * Returns Boolean true for valid columns, false for invalid columns.
  *
- * @param {DataFieldAbstractTypes} dataField Different DataField types defined in the annotations
- * @returns {boolean} True for valid columns, false for invalid columns
+ * @param dataField Different DataField types defined in the annotations
+ * @returns True for valid columns, false for invalid columns
  * @private
  */
 const _isValidColumn = function (dataField: DataFieldAbstractTypes) {
@@ -1596,23 +1576,20 @@ const _isValidColumn = function (dataField: DataFieldAbstractTypes) {
 		//  throw new Error("Unhandled DataField Abstract type: " + dataField.$Type);
 	}
 };
-
 /**
  * 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 {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.
+ * @param dataFieldModelPath The metapath referring to the annotation that is evaluated by SAP Fiori elements.
+ * @param [formatOptions] FormatOptions optional.
+ * @param formatOptions.isAnalytics This flag is used to check if the analytic table has GroupHeader expanded.
+ * @returns An expression that you can bind to the UI.
  */
 export const _getVisibleExpression = function (
 	dataFieldModelPath: DataModelObjectPath,
-	formatOptions?: any,
-	returnExpression: boolean = false
-): BindingExpression<string> {
+	formatOptions?: any
+): BindingToolkitExpression<any> {
 	const targetObject: DataFieldAbstractTypes | DataPointTypeTypes = dataFieldModelPath.targetObject;
 	let propertyValue;
 	if (targetObject) {
@@ -1644,41 +1621,43 @@ export const _getVisibleExpression = function (
 	// - 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(
+	return and(
 		...[
-			not(equal(annotationExpression(targetObject?.annotations?.UI?.Hidden), true)),
-			ifElse(!!propertyValue, propertyValue && not(equal(annotationExpression(propertyValue.annotations?.UI?.Hidden), true)), true),
+			not(equal(getExpressionFromAnnotation(targetObject?.annotations?.UI?.Hidden), true)),
+			ifElse(
+				!!propertyValue,
+				propertyValue && not(equal(getExpressionFromAnnotation(propertyValue.annotations?.UI?.Hidden), true)),
+				true
+			),
 			or(not(isAnalyticalGroupHeaderExpanded), isAnalyticalLeaf)
 		]
 	);
-	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 {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.
+ *
+ * @param dataFieldGroup DataField defined in the annotations
+ * @param fieldFormatOptions FormatOptions optional.
+ * @param fieldFormatOptions.isAnalytics This flag is used to check if the analytic table has GroupHeader expanded.
+ * @returns Compile binding of field group expressions.
  * @private
  */
 const _getFieldGroupHiddenExpressions = function (
 	dataFieldGroup: DataFieldAbstractTypes,
 	fieldFormatOptions: any
-): BindingExpression<string> | undefined {
-	const aFieldGroupHiddenExpressions: BindingExpression<string>[] = [];
+): CompiledBindingToolkitExpression | undefined {
+	const aFieldGroupHiddenExpressions: BindingToolkitExpression<any>[] = [];
 	if (
 		dataFieldGroup.$Type === UIAnnotationTypes.DataFieldForAnnotation &&
 		dataFieldGroup.Target?.$target?.$Type === UIAnnotationTypes.FieldGroupType
 	) {
 		dataFieldGroup.Target.$target.Data?.forEach((innerDataField: DataFieldAbstractTypes | DataPointTypeTypes) => {
 			aFieldGroupHiddenExpressions.push(
-				_getVisibleExpression({ targetObject: innerDataField } as DataModelObjectPath, fieldFormatOptions, true)
+				_getVisibleExpression({ targetObject: innerDataField } as DataModelObjectPath, fieldFormatOptions)
 			);
 		});
-		return compileBinding(
-			ifElse(or(...(aFieldGroupHiddenExpressions as any as ExpressionOrPrimitive<boolean>[])), constant(true), constant(false))
-		);
+		return compileExpression(ifElse(or(...aFieldGroupHiddenExpressions), constant(true), constant(false)));
 	} else {
 		return undefined;
 	}
@@ -1686,9 +1665,10 @@ const _getFieldGroupHiddenExpressions = function (
 
 /**
  * Returns the label for the property and dataField.
- * @param {DataFieldAbstractTypes | Property} [property] Property or DataField defined in the annotations
+ *
+ * @param [property] Property or DataField defined in the annotations
  * @param isGroup
- * @returns {string} Label of the property or DataField
+ * @returns Label of the property or DataField
  * @private
  */
 const _getLabel = function (property: DataFieldAbstractTypes | Property, isGroup: boolean = false): string | undefined {
@@ -1698,26 +1678,26 @@ const _getLabel = function (property: DataFieldAbstractTypes | Property, isGroup
 	if (isProperty(property)) {
 		const dataFieldDefault = property.annotations?.UI?.DataFieldDefault;
 		if (dataFieldDefault && !dataFieldDefault.qualifier && dataFieldDefault.Label?.valueOf()) {
-			return compileBinding(annotationExpression(dataFieldDefault.Label?.valueOf()));
+			return compileExpression(getExpressionFromAnnotation(dataFieldDefault.Label?.valueOf()));
 		}
-		return compileBinding(annotationExpression(property.annotations.Common?.Label?.valueOf() || property.name));
+		return compileExpression(getExpressionFromAnnotation(property.annotations.Common?.Label?.valueOf() || property.name));
 	} else if (isDataFieldTypes(property)) {
 		if (!!isGroup && property.$Type === UIAnnotationTypes.DataFieldWithIntentBasedNavigation) {
-			return compileBinding(annotationExpression(property.Label?.valueOf()));
+			return compileExpression(getExpressionFromAnnotation(property.Label?.valueOf()));
 		}
-		return compileBinding(
-			annotationExpression(
+		return compileExpression(
+			getExpressionFromAnnotation(
 				property.Label?.valueOf() || property.Value?.$target?.annotations?.Common?.Label?.valueOf() || property.Value?.$target?.name
 			)
 		);
 	} else if (property.$Type === UIAnnotationTypes.DataFieldForAnnotation) {
-		return compileBinding(
-			annotationExpression(
+		return compileExpression(
+			getExpressionFromAnnotation(
 				property.Label?.valueOf() || (property.Target?.$target as DataPoint)?.Value?.$target?.annotations?.Common?.Label?.valueOf()
 			)
 		);
 	} else {
-		return compileBinding(annotationExpression(property.Label?.valueOf()));
+		return compileExpression(getExpressionFromAnnotation(property.Label?.valueOf()));
 	}
 };
 
@@ -1728,36 +1708,36 @@ const _getTooltip = function (source: DataFieldAbstractTypes | Property): string
 
 	if (isProperty(source)) {
 		return source.annotations.Common?.QuickInfo
-			? compileBinding(annotationExpression(source.annotations.Common.QuickInfo.valueOf()))
+			? compileExpression(getExpressionFromAnnotation(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()))
+			? compileExpression(getExpressionFromAnnotation(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()))
+			? compileExpression(getExpressionFromAnnotation(datapointTarget.Value.$target.annotations.Common.QuickInfo.valueOf()))
 			: undefined;
 	} else {
 		return undefined;
 	}
 };
-export function getRowStatusVisibility(): Expression<boolean> {
+export function getRowStatusVisibility(): BindingToolkitExpression<boolean> {
 	return formatResult(
-		[bindingExpression(`semanticKeyHasDraftIndicator`, "internal"), bindingExpression(`filteredMessages`, "internal")],
+		[pathInModel(`semanticKeyHasDraftIndicator`, "internal"), pathInModel(`filteredMessages`, "internal")],
 		tableFormatters.getErrorStatusTextVisibilityFormatter
 	);
 }
 /**
  * Creates a PropertyInfo for each identified property consumed by a LineItem.
  *
- * @param {Record<string, Property>} columnsToBeCreated Identified properties.
+ * @param columnsToBeCreated Identified properties.
  * @param existingColumns The list of columns created for LineItems and Properties of entityType.
  * @param nonSortableColumns The array of column names which cannot be sorted.
  * @param converterContext The converter context.
  * @param entityType The entity type for the LineItem
- * @returns {AnnotationTableColumn[]} The array of columns created.
+ * @returns The array of columns created.
  */
 const _createRelatedColumns = function (
 	columnsToBeCreated: Record<string, Property>,
@@ -1798,7 +1778,7 @@ const _createRelatedColumns = function (
 			// Case 3: This is a self reference from an existing column and
 			// both cases require a dummy PropertyInfo for setting correct export settings.
 
-			const newName = "Property::" + name;
+			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)) {
@@ -1838,8 +1818,8 @@ const _createRelatedColumns = function (
  * If it points to a DataField with one property or DataPoint with one property, it will use the property name
  * here to be consistent with the existing flex changes.
  *
- * @param {DataFieldAbstractTypes} dataField Different DataField types defined in the annotations
- * @returns {string} The name of annotation columns
+ * @param dataField Different DataField types defined in the annotations
+ * @returns The name of annotation columns
  * @private
  */
 const _getAnnotationColumnName = function (dataField: DataFieldAbstractTypes) {
@@ -1856,10 +1836,11 @@ 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
+ *
+ * @param fieldGroupName The `DataField` name being processed.
+ * @param visualizationPath
+ * @param converterContext
+ * @returns `showDataFieldsLabel` value from the manifest
  * @private
  */
 const _getShowDataFieldsLabel = function (fieldGroupName: string, visualizationPath: string, converterContext: ConverterContext): boolean {
@@ -1875,8 +1856,9 @@ const _getShowDataFieldsLabel = function (fieldGroupName: string, visualizationP
 
 /**
  * Determines the relative path of the property with respect to the root entity.
+ *
  * @param dataField The `DataField` being processed.
- * @returns {string} The relative path
+ * @returns The relative path
  */
 const _getRelativePath = function (dataField: DataFieldAbstractTypes): string {
 	let relativePath: string = "";
@@ -1891,11 +1873,13 @@ const _getRelativePath = function (dataField: DataFieldAbstractTypes): string {
 			break;
 
 		case UIAnnotationTypes.DataFieldForAnnotation:
-			relativePath = (dataField as DataFieldForAnnotation)?.Target?.value;
+			relativePath = dataField?.Target?.value;
 			break;
 
 		case UIAnnotationTypes.DataFieldForAction:
 		case UIAnnotationTypes.DataFieldForIntentBasedNavigation:
+		case UIAnnotationTypes.DataFieldForActionGroup:
+		case UIAnnotationTypes.DataFieldWithActionGroup:
 			relativePath = KeyHelper.generateKeyFromDataField(dataField);
 			break;
 	}
@@ -1918,33 +1902,23 @@ const _sliceAtSlash = function (path: string, isLastSlash: boolean, isLastPart:
  * @param dataField The data field being processed
  * @param propertyPath The property path
  * @param nonSortableColumns Collection of non-sortable column names as per annotation
- * @returns {boolean} True if the column is sortable
+ * @returns True if the column is sortable
  */
 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
-		switch (dataField.$Type) {
-			case UIAnnotationTypes.DataField:
-			case UIAnnotationTypes.DataFieldWithUrl:
-				isSortable = true;
-				break;
-
-			case UIAnnotationTypes.DataFieldForIntentBasedNavigation:
-			case UIAnnotationTypes.DataFieldForAction:
-				// Action columns are not sortable
-				isSortable = false;
-				break;
-		}
-	}
-	return isSortable;
+	return (
+		nonSortableColumns.indexOf(propertyPath) === -1 && // Column is not marked as non-sortable via annotation
+		(dataField.$Type === UIAnnotationTypes.DataField ||
+			dataField.$Type === UIAnnotationTypes.DataFieldWithUrl ||
+			dataField.$Type === UIAnnotationTypes.DataFieldWithIntentBasedNavigation ||
+			dataField.$Type === UIAnnotationTypes.DataFieldWithAction)
+	);
 };
 
 /**
  * Returns whether filtering on the table is case sensitive.
  *
- * @param {ConverterContext} converterContext The instance of the converter context
- * @returns {boolean} Returns 'false' if FilterFunctions annotation supports 'tolower', else 'true'
+ * @param converterContext The instance of the converter context
+ * @returns Returns 'false' if FilterFunctions annotation supports 'tolower', else 'true'
  */
 export const isFilteringCaseSensitive = function (converterContext: ConverterContext): boolean {
 	const filterFunctions: FilterFunctions | undefined =
@@ -1956,7 +1930,7 @@ export const isFilteringCaseSensitive = function (converterContext: ConverterCon
 /**
  * Returns default format options for text fields in a table.
  *
- * @returns {FormatOptionsType} Collection of format options with default values
+ * @returns Collection of format options with default values
  */
 function getDefaultFormatOptionsForTable(): FormatOptionsType {
 	return {
@@ -2026,11 +2000,12 @@ function _findSemanticKeyValuesInFieldGroup(dataFieldGroup: DataFieldAbstractTyp
 
 /**
  * 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
+ * @returns Collection of format options with default values
  */
 function getDefaultDraftIndicatorForColumn(
 	name: string,
@@ -2047,18 +2022,16 @@ function getDefaultDraftIndicatorForColumn(
 		return {
 			hasDraftIndicator: true,
 			semantickeys: semanticKey.values,
-			objectStatusTextVisibility: compileBinding(getRowStatusVisibility())
+			objectStatusTextVisibility: compileExpression(getRowStatusVisibility())
 		};
+	} else if (!semanticKeyInFieldGroup.semanticKeyHasPropertyInFieldGroup) {
+		return {};
 	} else {
-		if (!semanticKeyInFieldGroup.semanticKeyHasPropertyInFieldGroup) {
-			return {};
-		} else {
-			// Semantic Key has a property in a FieldGroup
-			return {
-				FieldGroupDraftIndicatorPropertyPath: semanticKeyInFieldGroup.propertyPath,
-				FieldGroupName: name
-			};
-		}
+		// Semantic Key has a property in a FieldGroup
+		return {
+			FieldGroupDraftIndicatorPropertyPath: semanticKeyInFieldGroup.propertyPath,
+			FieldGroupName: name
+		};
 	}
 }
 
@@ -2104,7 +2077,7 @@ function _getMaxImportance(fields: DataFieldTypes[]): Importance {
  *
  * @param dataField
  * @param semanticKeys
- * @returns {Importance} The importance value
+ * @returns The importance value
  */
 export function getImportance(dataField: DataFieldAbstractTypes, semanticKeys: SemanticKey): Importance | undefined {
 	//Evaluate default Importance is not set explicitly
@@ -2158,10 +2131,10 @@ export function getImportance(dataField: DataFieldAbstractTypes, semanticKeys: S
 /**
  * Returns line items from metadata annotations.
  *
- * @param {LineItem} lineItemAnnotation Collection of data fields with their annotations
- * @param {string} visualizationPath The visualization path
- * @param {ConverterContext} converterContext The converter context
- * @returns {TableColumn[]} The columns from the annotations
+ * @param lineItemAnnotation Collection of data fields with their annotations
+ * @param visualizationPath The visualization path
+ * @param converterContext The converter context
+ * @returns The columns from the annotations
  */
 const getColumnsFromAnnotations = function (
 	lineItemAnnotation: LineItem,
@@ -2205,7 +2178,7 @@ const getColumnsFromAnnotations = function (
 				...getDefaultFormatOptionsForTable(),
 				...getDefaultDraftIndicatorForColumn(name, semanticKeys, isFieldGroupColumn, lineItem)
 			};
-			let fieldGroupHiddenExpressions: BindingExpression<string>;
+			let fieldGroupHiddenExpressions: CompiledBindingToolkitExpression;
 			if (
 				lineItem.$Type === UIAnnotationTypes.DataFieldForAnnotation &&
 				lineItem.Target?.$target?.$Type === UIAnnotationTypes.FieldGroupType
@@ -2247,7 +2220,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) {
@@ -2269,7 +2242,7 @@ const getColumnsFromAnnotations = function (
 				showDataFieldsLabel: showDataFieldsLabel,
 				relativePath: relativePath,
 				sortable: _isColumnSortable(lineItem, relativePath, nonSortableColumns),
-				propertyInfos: relatedPropertyNames.length > 0 ? relatedPropertyNames : undefined,
+				propertyInfos: relatedPropertyNames.length ? relatedPropertyNames : undefined,
 				additionalPropertyInfos: additionalPropertyNames.length > 0 ? additionalPropertyNames : undefined,
 				exportSettings: exportSettings,
 				width: lineItem.annotations?.HTML5?.CssDefaults?.width || undefined,
@@ -2290,14 +2263,14 @@ const getColumnsFromAnnotations = function (
 			annotationColumns.push(oColumn as AnnotationTableColumn);
 
 			// Collect information of related columns to be created.
-			relatedPropertyNames.forEach((name) => {
-				columnsToBeCreated[name] = relatedPropertiesInfo.properties[name];
+			relatedPropertyNames.forEach((relatedPropertyName) => {
+				columnsToBeCreated[relatedPropertyName] = relatedPropertiesInfo.properties[relatedPropertyName];
 			});
 
 			// Create columns for additional properties identified for ALP use case.
-			additionalPropertyNames.forEach((name) => {
+			additionalPropertyNames.forEach((additionalPropertyName) => {
 				// Intentional overwrite as we require only one new PropertyInfo for a related Property.
-				columnsToBeCreated[name] = relatedPropertiesInfo.additionalProperties[name];
+				columnsToBeCreated[additionalPropertyName] = relatedPropertiesInfo.additionalProperties[additionalPropertyName];
 			});
 		});
 	}
@@ -2323,11 +2296,12 @@ const getColumnsFromAnnotations = function (
 /**
  * Gets the property names from the manifest and checks against existing properties already added by annotations.
  * If a not yet stored property is found it adds it for sorting and filtering only to the annotationColumns.
- * @param {string[] | undefined} properties
- * @param {AnnotationTableColumn[]} annotationColumns
- * @param {ConverterContext} converterContext
+ *
+ * @param properties
+ * @param annotationColumns
+ * @param converterContext
  * @param entityType
- * @returns {string[]} The columns from the annotations
+ * @returns The columns from the annotations
  */
 const _getPropertyNames = function (
 	properties: string[] | undefined,
@@ -2374,10 +2348,10 @@ const _appendCustomTemplate = function (properties: string[]): string {
  * Manifest defined property value for custom / annotation columns
  * Default property value for custom column if not overwritten in manifest.
  *
- * @param {any} property The column property defined in the manifest
- * @param {any} defaultValue The default value of the property
- * @param {boolean} isAnnotationColumn Whether the column, defined in manifest, corresponds to an existing annotation column.
- * @returns {any} Determined property value for the column
+ * @param property The column property defined in the manifest
+ * @param defaultValue The default value of the property
+ * @param isAnnotationColumn Whether the column, defined in manifest, corresponds to an existing annotation column.
+ * @returns Determined property value for the column
  */
 const _getManifestOrDefaultValue = function (property: any, defaultValue: any, isAnnotationColumn: boolean): any {
 	if (property === undefined) {
@@ -2391,12 +2365,13 @@ const _getManifestOrDefaultValue = function (property: any, defaultValue: any, i
 
 /**
  * Returns table column definitions from manifest.
+ *
  * @param columns
  * @param annotationColumns
  * @param converterContext
  * @param entityType
  * @param navigationSettings
- * @returns {Record<string, CustomColumn>} The columns from the manifest
+ * @returns The columns from the manifest
  */
 const getColumnsFromManifest = function (
 	columns: Record<string, ManifestTableColumn>,
@@ -2419,7 +2394,7 @@ const getColumnsFromManifest = function (
 			entityType
 		);
 		if (!manifestColumn?.template && manifestColumn?.type !== "Slot" && !isAnnotationColumn) {
-			const Message = "The annotation column '" + key + "' referenced in the manifest is not found";
+			const Message = `The annotation column '${key}' referenced in the manifest is not found`;
 			converterContext
 				.getDiagnostics()
 				.addIssue(
@@ -2432,8 +2407,8 @@ const getColumnsFromManifest = function (
 		} else {
 			internalColumns[key] = {
 				key: key,
-				id: "CustomColumn::" + key,
-				name: "CustomColumn::" + key,
+				id: `CustomColumn::${key}`,
+				name: `CustomColumn::${key}`,
 				header: manifestColumn.header,
 				width: manifestColumn.width || undefined,
 				importance: _getManifestOrDefaultValue(manifestColumn?.importance, Importance.None, isAnnotationColumn),
@@ -2545,9 +2520,9 @@ export function getP13nMode(
  * Chart has a dependency to filter bar (issue with loading data). Once resolved, the check for chart should be removed here.
  * Until then, hiding filter bar is now allowed if a chart is being used on LR.
  *
- * @param {ManifestWrapper} manifestWrapper Manifest settings getter for the page
- * @param {ConverterContext} converterContext The instance of the converter context
- * @returns {boolean} Boolean suggesting if a filter bar is being used on the page.
+ * @param manifestWrapper Manifest settings getter for the page
+ * @param converterContext The instance of the converter context
+ * @returns Boolean suggesting if a filter bar is being used on the page.
  */
 function _isFilterBarHidden(manifestWrapper: ManifestWrapper, converterContext: ConverterContext): boolean {
 	return (
@@ -2561,13 +2536,13 @@ function _isFilterBarHidden(manifestWrapper: ManifestWrapper, converterContext:
  * Returns a JSON string containing the sort conditions for the presentation variant.
  *
  * @param converterContext The instance of the converter context
- * @param {PresentationVariantTypeTypes | undefined} presentationVariantAnnotation Presentation variant annotation
+ * @param presentationVariantAnnotation Presentation variant annotation
  * @param columns Table columns processed by the converter
- * @returns {string | undefined} Sort conditions for a presentation variant.
+ * @returns Sort conditions for a presentation variant.
  */
 function getSortConditions(
 	converterContext: ConverterContext,
-	presentationVariantAnnotation: PresentationVariantTypeTypes | undefined,
+	presentationVariantAnnotation: PresentationVariantType | undefined,
 	columns: TableColumn[]
 ): string | undefined {
 	// Currently navigation property is not supported as sorter
@@ -2623,18 +2598,19 @@ function convertPropertyPathsToInfoNames(paths: PropertyPath[], columns: TableCo
 /**
  * Returns a JSON string containing Presentation Variant group conditions.
  *
- * @param {PresentationVariantTypeTypes | undefined} presentationVariantAnnotation Presentation variant annotation
+ * @param presentationVariantAnnotation Presentation variant annotation
  * @param columns Converter processed table columns
- * @returns {string | undefined} Group conditions for a Presentation variant.
+ * @param tableType The table type.
+ * @returns Group conditions for a Presentation variant.
  */
 function getGroupConditions(
-	presentationVariantAnnotation: PresentationVariantTypeTypes | undefined,
+	presentationVariantAnnotation: PresentationVariantType | undefined,
 	columns: TableColumn[],
 	tableType: string
 ): string | undefined {
 	let groupConditions: string | undefined;
 	if (presentationVariantAnnotation?.GroupBy) {
-		let aGroupBy = presentationVariantAnnotation.GroupBy as PropertyPath[];
+		let aGroupBy = presentationVariantAnnotation.GroupBy;
 		if (tableType === "ResponsiveTable") {
 			aGroupBy = aGroupBy.slice(0, 1);
 		}
@@ -2650,17 +2626,17 @@ function getGroupConditions(
 /**
  * Returns a JSON string containing Presentation Variant aggregate conditions.
  *
- * @param {PresentationVariantTypeTypes | undefined} presentationVariantAnnotation Presentation variant annotation
+ * @param presentationVariantAnnotation Presentation variant annotation
  * @param columns Converter processed table columns
- * @returns {string | undefined} Group conditions for a Presentation variant.
+ * @returns Group conditions for a Presentation variant.
  */
 function getAggregateConditions(
-	presentationVariantAnnotation: PresentationVariantTypeTypes | undefined,
+	presentationVariantAnnotation: PresentationVariantType | undefined,
 	columns: TableColumn[]
 ): string | undefined {
 	let aggregateConditions: string | undefined;
 	if (presentationVariantAnnotation?.Total) {
-		const aTotals = presentationVariantAnnotation.Total as PropertyPath[];
+		const aTotals = presentationVariantAnnotation.Total;
 		const aggregates: Record<string, object> = {};
 		convertPropertyPathsToInfoNames(aTotals, columns).forEach((infoName) => {
 			aggregates[infoName] = {};
@@ -2678,7 +2654,7 @@ export function getTableAnnotationConfiguration(
 	converterContext: ConverterContext,
 	tableManifestConfiguration: TableControlConfiguration,
 	columns: TableColumn[],
-	presentationVariantAnnotation?: PresentationVariantTypeTypes,
+	presentationVariantAnnotation?: PresentationVariantType,
 	viewConfiguration?: ViewPathConfiguration
 ): TableAnnotationConfiguration {
 	// Need to get the target
@@ -2688,7 +2664,7 @@ export function getTableAnnotationConfiguration(
 	const pageManifestSettings: ManifestWrapper = converterContext.getManifestWrapper();
 	const hasAbsolutePath = navigationPropertyPath.length === 0,
 		p13nMode: string | undefined = getP13nMode(visualizationPath, converterContext, tableManifestConfiguration),
-		id = navigationPropertyPath ? TableID(visualizationPath) : TableID(converterContext.getContextPath(), "LineItem");
+		id = navigationPropertyPath ? getTableID(visualizationPath) : getTableID(converterContext.getContextPath(), "LineItem");
 	const targetCapabilities = getCapabilityRestriction(converterContext);
 	const navigationTargetPath = getNavigationTargetPath(converterContext, navigationPropertyPath);
 	const navigationSettings = pageManifestSettings.getNavigationConfiguration(navigationTargetPath);
@@ -2712,7 +2688,7 @@ export function getTableAnnotationConfiguration(
 	const isInsertUpdateTemplated = getInsertUpdateActionsTemplating(
 		standardActionsContext,
 		isDraftOrStickySupported(converterContext),
-		compileBinding(createButtonVisibilityExpression) === "false"
+		compileExpression(createButtonVisibilityExpression) === "false"
 	);
 
 	const selectionMode = getSelectionMode(
@@ -2813,7 +2789,7 @@ function _getExportDataType(dataType: string, isComplexProperty: boolean = false
  * Split the visualization path into the navigation property path and annotation.
  *
  * @param visualizationPath
- * @returns {object}
+ * @returns The split path
  */
 export function splitPath(visualizationPath: string) {
 	let [navigationPropertyPath, annotationPath] = visualizationPath.split("@");
@@ -2836,9 +2812,9 @@ export function getSelectionVariantConfiguration(
 		const propertyNames: string[] = [];
 		selection.SelectOptions?.forEach((selectOption: SelectOptionType) => {
 			const propertyName: any = selectOption.PropertyName;
-			const PropertyPath: string = propertyName.value;
-			if (propertyNames.indexOf(PropertyPath) === -1) {
-				propertyNames.push(PropertyPath);
+			const propertyPath: string = propertyName.value;
+			if (propertyNames.indexOf(propertyPath) === -1) {
+				propertyNames.push(propertyPath);
 			}
 		});
 		return {
@@ -2896,17 +2872,11 @@ function _getTableType(
 	converterContext: ConverterContext
 ): TableType {
 	let tableType = tableSettings?.type || "ResponsiveTable";
-	if (converterContext.getTemplateType() !== "ObjectPage") {
-		if (tableSettings?.type === "AnalyticalTable" && !aggregationHelper.isAnalyticsSupported()) {
-			tableType = "GridTable";
-		}
-		if (!tableSettings?.type) {
-			if (converterContext.getManifestWrapper().isDesktop() && aggregationHelper.isAnalyticsSupported()) {
-				tableType = "AnalyticalTable";
-			} else {
-				tableType = "ResponsiveTable";
-			}
-		}
+	/*  Now, we keep the configuration in the manifest, even if it leads to errors.
+		We only change if we're not on desktop from Analytical to Responsive.
+	 */
+	if (tableType === "AnalyticalTable" && !converterContext.getManifestWrapper().isDesktop()) {
+		tableType = "ResponsiveTable";
 	}
 	return tableType;
 }
@@ -2954,7 +2924,7 @@ function _getFilterConfiguration(
 	let quickSelectionVariant: any;
 	let filters;
 	tableSettings?.quickVariantSelection?.paths?.forEach((path: { annotationPath: string }) => {
-		quickSelectionVariant = targetEntityType.resolvePath("@" + path.annotationPath);
+		quickSelectionVariant = targetEntityType.resolvePath(`@${path.annotationPath}`);
 		filters = _getFilters(tableSettings, quickFilterPaths, quickSelectionVariant, path, converterContext);
 	});
 
@@ -3011,7 +2981,8 @@ export function getTableManifestConfiguration(
 		showRowCount:
 			!tableSettings?.quickVariantSelection?.showCounts && !converterContext.getManifestWrapper().getViewConfiguration()?.showCounts,
 		type: tableType,
-		useCondensedTableLayout: condensedTableLayout && isCondensedTableLayoutCompliant
+		useCondensedTableLayout: condensedTableLayout && isCondensedTableLayoutCompliant,
+		isCompactType: converterContext.getManifestWrapper().isCompactType()
 	};
 
 	return { ...oConfiguration, ...oFilterConfiguration };
@@ -3068,7 +3039,7 @@ export function getTypeConfig(oProperty: Property | DataFieldAbstractTypes, data
 			isDigitSequence:
 				propertyTypeConfig.type === "sap.ui.model.odata.type.String" &&
 				oTargetMapping.constraints?.["@com.sap.vocabularies.Common.v1.IsDigitSequence"] &&
-				(oProperty as Property).annotations?.Common?.IsDigitSequence
+				oProperty.annotations?.Common?.IsDigitSequence
 					? true
 					: undefined
 		};