@sapui5/sap.fe.core 1.112.0 → 1.114.0

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

@@ -5,11 +5,9 @@ import type {
 	PathAnnotationExpression,
 	Property,
 	PropertyAnnotationValue,
-	PropertyPath,
-	TypeDefinition
+	PropertyPath
 } from "@sap-ux/vocabularies-types";
 import type { FilterFunctions } from "@sap-ux/vocabularies-types/vocabularies/Capabilities";
-import type { EntitySetAnnotations_Capabilities } from "@sap-ux/vocabularies-types/vocabularies/Capabilities_Edm";
 import type { SemanticKey } from "@sap-ux/vocabularies-types/vocabularies/Common";
 import { CommonAnnotationTerms } from "@sap-ux/vocabularies-types/vocabularies/Common";
 import type { EntitySetAnnotations_Common } from "@sap-ux/vocabularies-types/vocabularies/Common_Edm";
@@ -76,7 +74,14 @@ import {
 } from "sap/fe/core/helpers/BindingToolkit";
 import ModelHelper from "sap/fe/core/helpers/ModelHelper";
 import { generate, replaceSpecialChars } from "sap/fe/core/helpers/StableIdHelper";
-import { isAnnotationOfType } from "sap/fe/core/helpers/TypeGuards";
+import * as TypeGuards from "sap/fe/core/helpers/TypeGuards";
+import {
+	isAnnotationOfType,
+	isNavigationProperty,
+	isPathAnnotationExpression,
+	isProperty,
+	isTypeDefinition
+} from "sap/fe/core/helpers/TypeGuards";
 import type { DataModelObjectPath } from "sap/fe/core/templating/DataModelPathHelper";
 import {
 	enhanceDataModelPath,
@@ -91,9 +96,9 @@ import {
 	getAssociatedCurrencyProperty,
 	getAssociatedTimezoneProperty,
 	getAssociatedUnitProperty,
-	isNavigationProperty,
-	isPathExpression,
-	isProperty
+	hasCurrency,
+	hasUnit,
+	isImageURL
 } from "sap/fe/core/templating/PropertyHelper";
 import { isMultiValueField } from "sap/fe/core/templating/UIFormatters";
 import type { DefaultTypeForEdmType } from "sap/fe/core/type/EDM";
@@ -130,7 +135,6 @@ import { getMessageTypeFromCriticalityType } from "./Criticality";
 import type { StandardActionConfigType } from "./table/StandardActions";
 import {
 	generateStandardActionsContext,
-	getCreateVisibility,
 	getCreationRow,
 	getDeleteVisibility,
 	getInsertUpdateActionsTemplating,
@@ -138,6 +142,7 @@ import {
 	getRestrictions,
 	getStandardActionCreate,
 	getStandardActionDelete,
+	getStandardActionInsights,
 	getStandardActionMassEdit,
 	getStandardActionPaste,
 	isDraftOrStickySupported,
@@ -209,12 +214,9 @@ export type TableCapabilityRestriction = {
 };
 
 export type TableFiltersConfiguration = {
-	enabled?: string | boolean;
-	paths: [
-		{
-			annotationPath: string;
-		}
-	];
+	paths: {
+		annotationPath: string;
+	}[];
 	showCounts?: boolean;
 };
 
@@ -230,10 +232,11 @@ export type TableControlConfiguration = {
 	customValidationFunction: string | undefined;
 	useCondensedTableLayout: boolean;
 	enableExport: boolean;
+	frozenColumnCount?: number;
 	headerVisible: boolean;
 	filters?: Record<string, TableFiltersConfiguration>;
 	type: TableType;
-	rowCountMode?: GridTableRowCountMode;
+	rowCountMode?: TableRowCountMode;
 	rowCount?: number;
 	selectAll?: boolean;
 	selectionLimit: number;
@@ -248,10 +251,11 @@ export type TableControlConfiguration = {
 	dataStateIndicatorFilter: string | undefined;
 	isCompactType?: boolean;
 	hierarchyQualifier?: string;
+	enableAddCardToInsights?: boolean | undefined;
 };
 
 export type TableType = "GridTable" | "ResponsiveTable" | "AnalyticalTable" | "TreeTable";
-export type GridTableRowCountMode = "Auto" | "Fixed";
+export type TableRowCountMode = "Auto" | "Fixed";
 
 enum ColumnType {
 	Default = "Default", // Default Type (Custom Column)
@@ -278,6 +282,8 @@ export type BaseTableColumn = ConfigurableObject & {
 	availability?: AvailabilityType;
 	isNavigable?: boolean;
 	caseSensitive: boolean;
+	isInsightsSupported?: boolean;
+	label?: string;
 };
 
 // Properties on Custom Columns and Slot Columns
@@ -379,6 +385,7 @@ export type AnnotationTableColumn = AnnotationTableColumnForOverride & {
 	exportDataPointTargetValue?: string;
 	aggregatable?: boolean;
 	extension?: ExtensionForAnalytics;
+	isInsightsSupported?: boolean;
 };
 
 export type ExtensionForAnalytics = {
@@ -436,6 +443,7 @@ export type TableVisualization = {
 	headerInfoTypeName: PropertyAnnotationValue<String> | undefined;
 	enable$select: boolean;
 	enable$$getKeepAliveContext: boolean;
+	isInsightsEnabled?: boolean;
 };
 
 type SorterType = {
@@ -494,15 +502,17 @@ export function getTableActions(
  * @param visualizationPath
  * @param converterContext
  * @param navigationSettings
+ * @param isInsightsEnabled
  * @returns Returns all table columns that should be available, regardless of templating or personalization or their origin
  */
 export function getTableColumns(
 	lineItemAnnotation: LineItem,
 	visualizationPath: string,
 	converterContext: ConverterContext,
-	navigationSettings?: NavigationSettingsConfiguration
+	navigationSettings?: NavigationSettingsConfiguration,
+	isInsightsEnabled?: boolean
 ): TableColumn[] {
-	const annotationColumns = getColumnsFromAnnotations(lineItemAnnotation, visualizationPath, converterContext);
+	const annotationColumns = getColumnsFromAnnotations(lineItemAnnotation, visualizationPath, converterContext, isInsightsEnabled);
 	const manifestColumns = getColumnsFromManifest(
 		converterContext.getManifestControlConfiguration(visualizationPath).columns,
 		annotationColumns,
@@ -657,7 +667,7 @@ export function updateTableVisualizationForType(
 		const aggregationHelper = new AggregationHelper(entityType, converterContext);
 		const allowedTransformations = aggregationHelper.getAllowedTransformations();
 		tableVisualization.enableBasicSearch = allowedTransformations ? allowedTransformations.includes("search") : true;
-		tableVisualization.enable$$getKeepAliveContext = false;
+		tableVisualization.enable$$getKeepAliveContext = true;
 	}
 }
 
@@ -727,7 +737,7 @@ export function updateLinkedProperties(entityType: EntityType, tableColumns: Tab
 
 				const displayMode = getDisplayMode(oProperty),
 					textAnnotation = oProperty.annotations.Common?.Text;
-				if (isPathExpression(textAnnotation) && displayMode !== "Value") {
+				if (isPathAnnotationExpression(textAnnotation) && displayMode !== "Value") {
 					const oTextColumn = findColumnByPath(textAnnotation.path);
 					if (oTextColumn && oTextColumn.name !== oTableColumn.name) {
 						oTableColumn.textArrangement = {
@@ -762,7 +772,8 @@ export function createTableVisualization(
 	converterContext: ConverterContext,
 	presentationVariantAnnotation?: PresentationVariantType,
 	isCondensedTableLayoutCompliant?: boolean,
-	viewConfiguration?: ViewPathConfiguration
+	viewConfiguration?: ViewPathConfiguration,
+	isInsightsEnabled?: boolean
 ): TableVisualization {
 	const tableManifestConfig = getTableManifestConfiguration(
 		lineItemAnnotation,
@@ -773,7 +784,7 @@ export function createTableVisualization(
 	const { navigationPropertyPath } = splitPath(visualizationPath);
 	const navigationTargetPath = getNavigationTargetPath(converterContext, navigationPropertyPath);
 	const navigationSettings = converterContext.getManifestWrapper().getNavigationConfiguration(navigationTargetPath);
-	const columns = getTableColumns(lineItemAnnotation, visualizationPath, converterContext, navigationSettings);
+	const columns = getTableColumns(lineItemAnnotation, visualizationPath, converterContext, navigationSettings, isInsightsEnabled);
 	const operationAvailableMap = getOperationAvailableMap(lineItemAnnotation, converterContext);
 	const semanticKeysAndHeaderInfoTitle = getSemanticKeysAndTitleInfo(converterContext);
 	const tableActions = getTableActions(lineItemAnnotation, visualizationPath, converterContext, navigationSettings);
@@ -787,7 +798,8 @@ export function createTableVisualization(
 			tableManifestConfig,
 			columns,
 			presentationVariantAnnotation,
-			viewConfiguration
+			viewConfiguration,
+			isInsightsEnabled
 		),
 		control: tableManifestConfig,
 		actions: removeDuplicateActions(tableActions.actions),
@@ -862,7 +874,7 @@ function getCurrentEntitySetUpdatablePath(converterContext: ConverterContext): s
 	const updatable = restrictions.isUpdatable;
 	const isOnlyDynamicOnCurrentEntity = !isConstant(updatable.expression) && updatable.navigationExpression._type === "Unresolvable";
 	const updatableExpression = entitySet?.annotations.Capabilities?.UpdateRestrictions?.Updatable;
-	const updatablePropertyPath = isPathExpression(updatableExpression) && updatableExpression.path;
+	const updatablePropertyPath = isPathAnnotationExpression(updatableExpression) && updatableExpression.path;
 
 	return isOnlyDynamicOnCurrentEntity ? (updatablePropertyPath as string) : "";
 }
@@ -962,7 +974,7 @@ function getBindingExpFromContext(
 		sExpression = (source as CustomAction)?.visible;
 	}
 	let sPath: string;
-	if (isPathExpression(sExpression)) {
+	if (isPathAnnotationExpression(sExpression)) {
 		sPath = sExpression.path;
 	} else {
 		sPath = sExpression as string;
@@ -976,7 +988,7 @@ function getBindingExpFromContext(
 			const aSplitPath = sPath.split("/");
 			const sNavigationPath = aSplitPath[0];
 			if (
-				contextDataModelObjectPath?.targetObject?._type === "NavigationProperty" &&
+				isNavigationProperty(contextDataModelObjectPath?.targetObject) &&
 				contextDataModelObjectPath.targetObject.partner === sNavigationPath
 			) {
 				return pathInModel(aSplitPath.slice(1).join("/"));
@@ -1334,11 +1346,24 @@ function getTableAnnotationActions(lineItemAnnotation: LineItem, visualizationPa
 			) {
 				switch (dataField.$Type) {
 					case UIAnnotationTypes.DataFieldForAction:
-						// If the action has an overload (bound to parent entity) and there is an OperationAvailable annotation
-						// create the enable expression. The action enablement is not dependent upon the table entries.
-						const useEnabledExpression =
-							dataField.ActionTarget?.annotations?.Core?.OperationAvailable !== undefined &&
-							dataField.ActionTarget?.sourceType !== sEntityType;
+						// There are three cases when a table action has an OperationAvailable that leads to an enablement expression
+						// and is not dependent upon the table entries.
+						// 1. An action with an overload, that is executed against a parent entity.
+						// 2. An unbound action
+						// 3. A static action (that is, bound to a collection)
+						let useEnabledExpression = false;
+						if (dataField.ActionTarget?.annotations?.Core?.OperationAvailable !== undefined) {
+							if (!dataField.ActionTarget?.isBound) {
+								// Unbound action. Is recognised, but getExpressionFromAnnotation checks for isBound = true, so not generated.
+								useEnabledExpression = true;
+							} else if (dataField.ActionTarget?.isBound && dataField.ActionTarget?.sourceType !== sEntityType) {
+								// Overload action
+								useEnabledExpression = true;
+							} else if (dataField.ActionTarget?.parameters[0].isCollection) {
+								// Static action
+								useEnabledExpression = true;
+							}
+						}
 
 						const tableAction: BaseAction = {
 							type: ActionType.DataFieldForAction,
@@ -1514,28 +1539,26 @@ const _getRowConfigurationProperty = function (
 	const targetEntityType = converterContext.getEntityType();
 	if (navigationSettings && lineItemAnnotation) {
 		navigationTarget = navigationSettings.display?.target || navigationSettings.detail?.outbound;
+		const targetEntitySet = converterContext.getEntitySet();
+		criticalityProperty = getHighlightRowBinding(
+			lineItemAnnotation.annotations?.UI?.Criticality,
+			!!ModelHelper.getDraftRoot(targetEntitySet) || !!ModelHelper.getDraftNode(targetEntitySet),
+			targetEntityType
+		);
 		if (navigationTarget) {
 			pressProperty =
 				".handlers.onChevronPressNavigateOutBound( $controller ,'" + navigationTarget + "', ${$parameters>bindingContext})";
-		} else if (targetEntityType) {
-			const targetEntitySet = converterContext.getEntitySet();
-			navigationTarget = navigationSettings.detail?.route;
-			criticalityProperty = getHighlightRowBinding(
-				lineItemAnnotation.annotations?.UI?.Criticality,
-				!!ModelHelper.getDraftRoot(targetEntitySet) || !!ModelHelper.getDraftNode(targetEntitySet),
-				targetEntityType
-			);
-			if (navigationTarget && !ModelHelper.isSingleton(targetEntitySet)) {
-				pressProperty =
-					"API.onTableRowPress($event, $controller, ${$parameters>bindingContext}, { callExtension: true, targetPath: '" +
-					targetPath +
-					"', editable : " +
-					(ModelHelper.getDraftRoot(targetEntitySet) || ModelHelper.getDraftNode(targetEntitySet)
-						? "!${$parameters>bindingContext}.getProperty('IsActiveEntity')"
-						: "undefined") +
-					(tableType === "AnalyticalTable" || tableType === "TreeTable" ? ", bRecreateContext: true" : "") +
-					"})"; //Need to access to DraftRoot and DraftNode !!!!!!!
-			}
+		}
+		if (!navigationTarget && navigationSettings.detail?.route) {
+			pressProperty =
+				"API.onTableRowPress($event, $controller, ${$parameters>bindingContext}, { callExtension: true, targetPath: '" +
+				targetPath +
+				"', editable : " +
+				(ModelHelper.getDraftRoot(targetEntitySet) || ModelHelper.getDraftNode(targetEntitySet)
+					? "!${$parameters>bindingContext}.getProperty('IsActiveEntity')"
+					: "undefined") +
+				(tableType === "AnalyticalTable" || tableType === "TreeTable" ? ", bRecreateContext: true" : "") +
+				"})"; //Need to access to DraftRoot and DraftNode !!!!!!!
 		}
 	}
 	const rowNavigatedExpression: BindingToolkitExpression<boolean> = formatResult(
@@ -1610,15 +1633,6 @@ export const getColumnsFromEntityType = function (
 				textOnlyColumnsFromTextAnnotation
 			);
 
-			const semanticKeys = converterContext.getAnnotationsByTerm("Common", CommonAnnotationTerms.SemanticKey, [
-				converterContext.getEntityType()
-			])[0];
-			const oColumnDraftIndicator = getDefaultDraftIndicatorForColumn(columnInfo.name, semanticKeys, false, null);
-			if (Object.keys(oColumnDraftIndicator).length > 0) {
-				columnInfo.formatOptions = {
-					...oColumnDraftIndicator
-				};
-			}
 			if (relatedPropertyNames.length > 0) {
 				columnInfo.propertyInfos = relatedPropertyNames;
 				columnInfo.exportSettings = {
@@ -2053,19 +2067,21 @@ const _createRelatedColumns = function (
 		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.
-			relatedColumns.push(
-				getColumnDefinitionFromProperty(
-					property,
-					annotationPath,
-					name,
-					true,
-					false,
-					nonSortableColumns,
-					aggregationHelper,
-					converterContext,
-					textOnlyColumnsFromTextAnnotation
-				)
+			const column = getColumnDefinitionFromProperty(
+				property,
+				annotationPath,
+				name,
+				true,
+				false,
+				nonSortableColumns,
+				aggregationHelper,
+				converterContext,
+				textOnlyColumnsFromTextAnnotation
+			);
+			column.isPartOfLineItem = existingColumns.some(
+				(existingColumn) => existingColumn.propertyInfos?.includes(name) && existingColumn.isPartOfLineItem
 			);
+			relatedColumns.push(column);
 		} else if (relatedColumn.annotationPath !== annotationPath || relatedColumn.propertyInfos) {
 			// Case 2: The existing column points to a LineItem (or)
 			// Case 3: This is a self reference from an existing column
@@ -2122,7 +2138,7 @@ const _createRelatedColumns = function (
  */
 const _getAnnotationColumnName = function (dataField: DataFieldAbstractTypes) {
 	// This is needed as we have flexibility changes already that we have to check against
-	if (isDataFieldTypes(dataField)) {
+	if (isDataFieldTypes(dataField) && dataField.Value?.path) {
 		return dataField.Value?.path;
 	} else if (dataField.$Type === UIAnnotationTypes.DataFieldForAnnotation && (dataField.Target?.$target as DataPoint)?.Value?.path) {
 		// This is for removing duplicate properties. For example, 'Progress' Property is removed if it is already defined as a DataPoint
@@ -2245,7 +2261,7 @@ const _sliceAtSlash = function (path: string, isLastSlash: boolean, isLastPart:
  * @returns True if the DataField corresponds to a multi-value field.
  */
 const _isColumnMultiValued = function (dataField: DataFieldAbstractTypes, converterContext: ConverterContext): boolean {
-	if (isDataFieldTypes(dataField) && isPathExpression(dataField.Value)) {
+	if (isDataFieldTypes(dataField) && isPathAnnotationExpression(dataField.Value)) {
 		const propertyObjectPath = enhanceDataModelPath(converterContext.getDataModelObjectPath(), dataField.Value.path);
 		return isMultiValueField(propertyObjectPath);
 	} else {
@@ -2283,11 +2299,14 @@ export const isFilteringCaseSensitive = function (converterContext: ConverterCon
 };
 
 function _getFilterFunctions(ConverterContext: ConverterContext): FilterFunctions | undefined {
-	if (ModelHelper.isSingleton(ConverterContext.getEntitySet())) {
-		return undefined;
+	const entitySet = ConverterContext.getEntitySet();
+	if (TypeGuards.isEntitySet(entitySet)) {
+		return (
+			entitySet.annotations.Capabilities?.FilterFunctions ??
+			ConverterContext.getEntityContainer().annotations.Capabilities?.FilterFunctions
+		);
 	}
-	const capabilities = ConverterContext.getEntitySet()?.annotations?.Capabilities as EntitySetAnnotations_Capabilities;
-	return capabilities?.FilterFunctions || ConverterContext.getEntityContainer()?.annotations?.Capabilities?.FilterFunctions;
+	return undefined;
 }
 
 /**
@@ -2338,7 +2357,15 @@ function _findProperties(semanticKeyValues: string[], fieldGroupProperties: stri
 	};
 }
 
+/**
+ * Find the first property in the fieldGroup that is part of the semantic keys.
+ *
+ * @param dataFieldGroup
+ * @param semanticKeyValues
+ * @returns An object containing a flag true if a property is found and a propertyPath.
+ */
 function _findSemanticKeyValuesInFieldGroup(dataFieldGroup: DataFieldAbstractTypes | null, semanticKeyValues: string[]) {
+	// this info is used in FieldlHelper#isDraftIndicatorVisibleInFieldGroup to show a draft indicator at the end of a field group
 	const aProperties: string[] = [];
 	let _propertiesFound: { semanticKeyHasPropertyInFieldGroup: boolean; fieldGroupPropertyPath?: string } = {
 		semanticKeyHasPropertyInFieldGroup: false,
@@ -2379,33 +2406,31 @@ function getDefaultDraftIndicatorForColumn(
 	semanticKeys: SemanticKey,
 	isFieldGroupColumn: boolean,
 	dataFieldGroup: DataFieldAbstractTypes | null
-) {
+): Partial<{
+	fieldGroupDraftIndicatorPropertyPath: string;
+	fieldGroupName: string;
+	showErrorObjectStatus: CompiledBindingToolkitExpression;
+	hasDraftIndicator: boolean;
+}> {
 	if (!semanticKeys) {
 		return {};
 	}
 	const semanticKey = _findSemanticKeyValues(semanticKeys, name);
 	const semanticKeyInFieldGroup = _findSemanticKeyValuesInFieldGroup(dataFieldGroup, semanticKey.values);
-	if (semanticKey.semanticKeyFound) {
-		const formatOptionsObj: FormatOptionsType = {
-			hasDraftIndicator: true,
-			semantickeys: semanticKey.values,
-			objectStatusTextVisibility: compileExpression(getRowStatusVisibility(name, false))
-		};
-		if (isFieldGroupColumn && semanticKeyInFieldGroup.semanticKeyHasPropertyInFieldGroup) {
-			formatOptionsObj.objectStatusTextVisibility = compileExpression(getRowStatusVisibility(name, true));
-			formatOptionsObj.fieldGroupDraftIndicatorPropertyPath = semanticKeyInFieldGroup.propertyPath;
-		}
-		return formatOptionsObj;
-	} else if (!semanticKeyInFieldGroup.semanticKeyHasPropertyInFieldGroup) {
-		return {};
-	} else {
+	if (semanticKeyInFieldGroup.semanticKeyHasPropertyInFieldGroup) {
 		// Semantic Key has a property in a FieldGroup
 		return {
+			//TODO we should rather store hasSemanticKeyInFieldGroup
 			fieldGroupDraftIndicatorPropertyPath: semanticKeyInFieldGroup.propertyPath,
-			fieldGroupName: name,
-			objectStatusTextVisibility: compileExpression(getRowStatusVisibility(name, true))
+			fieldGroupName: name
+		};
+	} else if (semanticKey.semanticKeyFound) {
+		return {
+			hasDraftIndicator: true,
+			showErrorObjectStatus: compileExpression(getRowStatusVisibility(name, false))
 		};
 	}
+	return {};
 }
 
 function _getImpNumber(dataField: DataFieldTypes): number {
@@ -2506,18 +2531,49 @@ export function getImportance(dataField: DataFieldAbstractTypes | undefined, sem
 		: _getDataFieldImportance(dataField as unknown as DataFieldTypes);
 }
 
+/**
+ * Checks if displaying of the column is supported for an insights card.
+ *
+ * @param dataField
+ * @param sLabel
+ * @param converterContext
+ * @param isMultiValue
+ * @returns True if displaying of the column is supported for an insights card.
+ */
+const checkIfColumnIsSupportedForInsights = function (
+	dataField: DataFieldAbstractTypes,
+	sLabel: string | undefined,
+	converterContext: ConverterContext,
+	isMultiValue: boolean
+) {
+	const annotationPath = converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName);
+
+	if (sLabel && sLabel !== "" && annotationPath.indexOf("@com.sap.vocabularies.UI.v1.LineItem") !== -1 && isDataFieldTypes(dataField)) {
+		// include only those columns that are annotated as part of the table (skip entity props)
+
+		const isMeasureBasedColumn = hasUnit(dataField.Value.$target) || hasCurrency(dataField.Value.$target);
+		const isImageColumn = dataField.Value?.$target ? isImageURL(dataField.Value.$target) : false;
+
+		return !isMultiValue && !isImageColumn && !isMeasureBasedColumn;
+	}
+
+	return false;
+};
+
 /**
  * Returns line items from metadata annotations.
  *
  * @param lineItemAnnotation Collection of data fields with their annotations
  * @param visualizationPath The visualization path
  * @param converterContext The converter context
+ * @param isInsightsEnabled
  * @returns The columns from the annotations
  */
 const getColumnsFromAnnotations = function (
 	lineItemAnnotation: LineItem,
 	visualizationPath: string,
-	converterContext: ConverterContext
+	converterContext: ConverterContext,
+	isInsightsEnabled?: boolean
 ): AnnotationTableColumn[] {
 	const entityType = converterContext.getAnnotationEntityType(lineItemAnnotation),
 		annotationColumns: AnnotationTableColumn[] = [],
@@ -2535,6 +2591,7 @@ const getColumnsFromAnnotations = function (
 		);
 
 		lineItemAnnotation.forEach((lineItem) => {
+			// TODO: variable name should be datafield and not lineItem
 			if (!_isValidColumn(lineItem)) {
 				return;
 			}
@@ -2544,16 +2601,15 @@ const getColumnsFromAnnotations = function (
 					? getSemanticObjectPath(converterContext, lineItem)
 					: undefined;
 			const relativePath = _getRelativePath(lineItem);
-
 			// Determine properties which are consumed by this LineItem.
 			const relatedPropertiesInfo: ComplexPropertyInfo = collectRelatedPropertiesRecursively(lineItem, converterContext, tableType);
 			const relatedPropertyNames: string[] = Object.keys(relatedPropertiesInfo.properties);
 			const additionalPropertyNames: string[] = Object.keys(relatedPropertiesInfo.additionalProperties);
-			const groupPath: string = _sliceAtSlash(relativePath, true, false);
+			const groupPath: string | undefined = relativePath ? _sliceAtSlash(relativePath, true, false) : undefined;
 			const isGroup: boolean = groupPath != relativePath;
 			const sLabel: string | undefined = getLabel(lineItem, isGroup);
 			const name = _getAnnotationColumnName(lineItem);
-			const isFieldGroupColumn: boolean = groupPath.indexOf(`@${UIAnnotationTerms.FieldGroup}`) > -1;
+			const isFieldGroupColumn: boolean = groupPath ? groupPath.indexOf(`@${UIAnnotationTerms.FieldGroup}`) > -1 : false;
 			const showDataFieldsLabel: boolean = isFieldGroupColumn
 				? _getShowDataFieldsLabel(name, visualizationPath, converterContext)
 				: false;
@@ -2611,6 +2667,8 @@ const getColumnsFromAnnotations = function (
 			}
 			const isMultiValue = _isColumnMultiValued(lineItem, tableConverterContext);
 			const sortable = !isMultiValue && _isColumnSortable(lineItem, relativePath, nonSortableColumns);
+			const tableManifestConfig = converterContext.getManifestControlConfiguration(visualizationPath);
+			const enableAddCardToInsights = tableManifestConfig.tableSettings?.enableAddCardToInsights ?? true;
 			const column: AnnotationTableColumn = {
 				key: KeyHelper.generateKeyFromDataField(lineItem),
 				type: ColumnType.Annotation,
@@ -2638,6 +2696,10 @@ const getColumnsFromAnnotations = function (
 				timezoneText: exportSettings?.timezone,
 				isPartOfLineItem: true
 			};
+			column.isInsightsSupported =
+				enableAddCardToInsights === true &&
+				isInsightsEnabled === true &&
+				checkIfColumnIsSupportedForInsights(lineItem, sLabel, converterContext, isMultiValue);
 			const sTooltip = _getTooltip(lineItem);
 			if (sTooltip) {
 				column.tooltip = sTooltip;
@@ -3132,7 +3194,8 @@ export function getTableAnnotationConfiguration(
 	tableManifestConfiguration: TableControlConfiguration,
 	columns: TableColumn[],
 	presentationVariantAnnotation?: PresentationVariantType,
-	viewConfiguration?: ViewPathConfiguration
+	viewConfiguration?: ViewPathConfiguration,
+	isInsightsEnabled?: boolean
 ): TableAnnotationConfiguration {
 	// Need to get the target
 	const { navigationPropertyPath } = splitPath(visualizationPath);
@@ -3157,17 +3220,13 @@ export function getTableAnnotationConfiguration(
 		converterContext,
 		creationBehaviour.mode as CreationMode,
 		tableManifestConfiguration,
-		viewConfiguration
+		viewConfiguration,
+		isInsightsEnabled
 	);
 
 	const deleteButtonVisibilityExpression = getDeleteVisibility(converterContext, standardActionsContext);
-	const createButtonVisibilityExpression = getCreateVisibility(converterContext, standardActionsContext);
 	const massEditButtonVisibilityExpression = getMassEditVisibility(converterContext, standardActionsContext);
-	const isInsertUpdateTemplated = getInsertUpdateActionsTemplating(
-		standardActionsContext,
-		isDraftOrStickySupported(converterContext),
-		compileExpression(createButtonVisibilityExpression) === "false"
-	);
+	const isInsertUpdateTemplated = getInsertUpdateActionsTemplating(standardActionsContext, isDraftOrStickySupported(converterContext));
 
 	const selectionMode = getSelectionMode(
 		lineItemAnnotation,
@@ -3190,6 +3249,7 @@ export function getTableAnnotationConfiguration(
 		delete: getStandardActionDelete(converterContext, standardActionsContext),
 		paste: getStandardActionPaste(converterContext, standardActionsContext, isInsertUpdateTemplated),
 		massEdit: getStandardActionMassEdit(converterContext, standardActionsContext),
+		insights: getStandardActionInsights(converterContext, standardActionsContext, visualizationPath),
 		creationRow: getCreationRow(converterContext, standardActionsContext)
 	};
 
@@ -3360,12 +3420,12 @@ function _getTableType(
 	return tableType;
 }
 
-function _getGridTableMode(
+function _getTableMode(
 	tableType: TableType,
 	tableSettings: TableManifestSettingsConfiguration,
 	isTemplateListReport: boolean
-): { rowCountMode?: GridTableRowCountMode; rowCount?: number } {
-	if (tableType === "GridTable") {
+): { rowCountMode?: TableRowCountMode; rowCount?: number } {
+	if (tableType !== "ResponsiveTable") {
 		if (isTemplateListReport) {
 			return {
 				rowCountMode: "Auto",
@@ -3400,15 +3460,13 @@ function _getFilters(
 	tableSettings: TableManifestSettingsConfiguration,
 	quickFilterPaths: { annotationPath: string }[],
 	quickSelectionVariant: unknown,
-	path: { annotationPath: string },
-	converterContext: ConverterContext
+	path: { annotationPath: string }
 ) {
 	if (quickSelectionVariant) {
 		quickFilterPaths.push({ annotationPath: path.annotationPath });
 	}
 	return {
 		quickFilters: {
-			enabled: converterContext.getTemplateType() !== TemplateType.ListReport,
 			showCounts: tableSettings?.quickVariantSelection?.showCounts,
 			paths: quickFilterPaths
 		}
@@ -3425,6 +3483,10 @@ function _getEnableExport(
 		: converterContext.getTemplateType() !== "ObjectPage" || enablePaste;
 }
 
+function _getFrozenColumnCount(tableSettings: TableManifestSettingsConfiguration): number | undefined {
+	return tableSettings.frozenColumnCount;
+}
+
 function _getFilterConfiguration(
 	tableSettings: TableManifestSettingsConfiguration,
 	lineItemAnnotation: LineItem | undefined,
@@ -3439,7 +3501,7 @@ function _getFilterConfiguration(
 	let filters;
 	tableSettings?.quickVariantSelection?.paths?.forEach((path: { annotationPath: string }) => {
 		quickSelectionVariant = targetEntityType.resolvePath(path.annotationPath);
-		filters = _getFilters(tableSettings, quickFilterPaths, quickSelectionVariant, path, converterContext);
+		filters = _getFilters(tableSettings, quickFilterPaths, quickSelectionVariant, path);
 	});
 
 	let hideTableTitle = false;
@@ -3482,7 +3544,7 @@ export function getTableManifestConfiguration(
 	const entityType = converterContext.getEntityType();
 	const aggregationHelper = new AggregationHelper(entityType, converterContext);
 	const tableType: TableType = _getTableType(tableSettings, aggregationHelper, converterContext);
-	const gridTableRowMode = _getGridTableMode(tableType, tableSettings, templateType === TemplateType.ListReport);
+	const tableRowMode = _getTableMode(tableType, tableSettings, templateType === TemplateType.ListReport);
 	const condensedTableLayout = _getCondensedTableLayout(tableType, tableSettings);
 	const oConfiguration = {
 		// If no createAtEnd is specified it will be false for Inline create and true otherwise
@@ -3497,8 +3559,10 @@ export function getTableManifestConfiguration(
 		disableAddRowButtonForEmptyData: !customValidationFunction ? !!tableSettings.creationMode?.disableAddRowButtonForEmptyData : false,
 		enableAutoColumnWidth: enableAutoColumnWidth,
 		enableExport: _getEnableExport(tableSettings, converterContext, enablePaste),
+		frozenColumnCount: _getFrozenColumnCount(tableSettings),
 		enableFullScreen: _getFullScreenBasedOnDevice(tableSettings, converterContext, _manifestWrapper.isPhone()),
 		enableMassEdit: tableSettings?.enableMassEdit,
+		enableAddCardToInsights: tableSettings?.enableAddCardToInsights,
 		enablePaste: enablePaste,
 		headerVisible: true,
 		multiSelectMode: _getMultiSelectMode(tableSettings, tableType, converterContext),
@@ -3511,7 +3575,7 @@ export function getTableManifestConfiguration(
 		isCompactType: _manifestWrapper.isCompactType()
 	};
 
-	const tableConfiguration: TableControlConfiguration = { ...oConfiguration, ...gridTableRowMode, ...oFilterConfiguration };
+	const tableConfiguration: TableControlConfiguration = { ...oConfiguration, ...tableRowMode, ...oFilterConfiguration };
 
 	if (tableType === "TreeTable") {
 		tableConfiguration.hierarchyQualifier = tableSettings.hierarchyQualifier;
@@ -3521,16 +3585,22 @@ export function getTableManifestConfiguration(
 }
 
 export function getTypeConfig(oProperty: Property | DataFieldAbstractTypes, dataType: string | undefined): PropertyTypeConfig {
-	let oTargetMapping = EDM_TYPE_MAPPING[(oProperty as Property)?.type] || (dataType ? EDM_TYPE_MAPPING[dataType] : undefined);
-	if (!oTargetMapping && (oProperty as Property)?.targetType && (oProperty as Property).targetType?._type === "TypeDefinition") {
-		oTargetMapping = EDM_TYPE_MAPPING[((oProperty as Property).targetType as TypeDefinition).underlyingType];
+	let oTargetMapping;
+	if (isProperty(oProperty)) {
+		oTargetMapping = isTypeDefinition(oProperty.targetType)
+			? EDM_TYPE_MAPPING[oProperty.targetType.underlyingType]
+			: EDM_TYPE_MAPPING[oProperty.type];
+	}
+	if (oTargetMapping === undefined && dataType !== undefined) {
+		oTargetMapping = EDM_TYPE_MAPPING[dataType];
 	}
+
 	const propertyTypeConfig: PropertyTypeConfig = {
 		type: oTargetMapping?.type,
 		constraints: {},
 		formatOptions: {}
 	};
-	if (isProperty(oProperty)) {
+	if (isProperty(oProperty) && oTargetMapping !== undefined) {
 		propertyTypeConfig.constraints = {
 			scale: oTargetMapping.constraints?.$Scale ? oProperty.scale : undefined,
 			precision: oTargetMapping.constraints?.$Precision ? oProperty.precision : undefined,