@sap/ux-specification 1.144.5 → 1.144.7

package/dist/specification/src/sync/v4/utils/utils.js

@@ -36,7 +36,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QUALIFIER_SEPARATOR = exports.FIELD_SEPARATOR = exports.DATA_FIELD_FOR_ACTION_GROUP = void 0;
+exports.QUALIFIER_SEPARATOR = exports.FIELD_SEPARATOR = exports.DATA_FIELD_FOR_ACTION_GROUP = exports.MIN_UI5_VERSION_FOR_TABLE_TYPE_RESTRICTIONS = void 0;
+exports.hasEmbeddedComponent = hasEmbeddedComponent;
 exports.addExtensionToArray = addExtensionToArray;
 exports.getColumnsEnum = getColumnsEnum;
 exports.addEnumForProperties = addEnumForProperties;
@@ -70,8 +71,13 @@ exports.importActionSettingsOfReference = importActionSettingsOfReference;
 exports.addCustomFieldDefinition = addCustomFieldDefinition;
 exports.addManifestPathsToProperties = addManifestPathsToProperties;
 exports.getInsertableForEntitySet = getInsertableForEntitySet;
+exports.getDefaultTableType = getDefaultTableType;
+exports.getTableTypeOptions = getTableTypeOptions;
+exports.ensureEntitySetWithCorrectType = ensureEntitySetWithCorrectType;
+exports.getTableTypeOptionsByContext = getTableTypeOptionsByContext;
 exports.getPageManifestPath = getPageManifestPath;
 const utils_1 = require("../../common/utils");
+const importProject_1 = require("../../common/importProject");
 const StableIdHelper_1 = require("./StableIdHelper");
 const common_1 = require("../../common");
 const i18next_1 = __importDefault(require("i18next"));
@@ -83,8 +89,75 @@ const utils_2 = require("../import/utils");
 const src_1 = require("@sap/ux-specification-types/src");
 const v4controls = __importStar(require("../export/controls"));
 const pages = __importStar(require("../export/pages"));
+const v4_1 = require("@sap/ux-specification-types/src/v4");
+const project_access_1 = require("@sap-ux/project-access");
 const application_1 = require("../application");
 const propertiesForEdit_1 = require("../generate/utils/propertiesForEdit");
+const utils_3 = require("../sync-rules/utils");
+/**
+ * Map of table type options based on the detected default table type.
+ * Each table type has a predefined set of compatible options and a default type.
+ */
+const TABLE_TYPE_OPTIONS_MAP = {
+    [v4_1.TableTypeV4.AnalyticalTable]: {
+        options: [v4_1.TableTypeV4.AnalyticalTable, v4_1.TableTypeV4.ResponsiveTable, v4_1.TableTypeV4.GridTable],
+        defaultType: v4_1.TableTypeV4.AnalyticalTable
+    },
+    [v4_1.TableTypeV4.TreeTable]: {
+        options: [v4_1.TableTypeV4.TreeTable, v4_1.TableTypeV4.ResponsiveTable, v4_1.TableTypeV4.GridTable],
+        defaultType: v4_1.TableTypeV4.TreeTable
+    },
+    [v4_1.TableTypeV4.ResponsiveTable]: {
+        options: [v4_1.TableTypeV4.ResponsiveTable, v4_1.TableTypeV4.GridTable],
+        defaultType: v4_1.TableTypeV4.ResponsiveTable
+    },
+    [v4_1.TableTypeV4.GridTable]: {
+        options: [v4_1.TableTypeV4.ResponsiveTable, v4_1.TableTypeV4.GridTable],
+        defaultType: v4_1.TableTypeV4.ResponsiveTable
+    }
+};
+/**
+ * Default table type used as a fallback when entity set is undefined or capabilities cannot be determined.
+ * ResponsiveTable is chosen as the safest and most universally applicable option.
+ */
+const FALLBACK_TABLE_TYPE = v4_1.TableTypeV4.ResponsiveTable;
+/**
+ * Fallback table type options used when entity set capabilities cannot be determined.
+ * Derives from FALLBACK_TABLE_TYPE to ensure consistency across fallback scenarios.
+ */
+const FALLBACK_TABLE_TYPE_OPTIONS = TABLE_TYPE_OPTIONS_MAP[FALLBACK_TABLE_TYPE];
+/**
+ * Minimum UI5 version that supports capability-based table type restrictions.
+ *
+ * Before 1.142.0:
+ * - Table type was optional
+ * - All table types were available regardless of service capabilities
+ * - No warning messages for missing table type or type-dependent properties
+ *
+ * From 1.142.0 onwards:
+ * - Table type options are restricted based on entity set capabilities (analytical/hierarchical/standard)
+ * - Warning messages are shown when table type is missing but type-dependent properties exist
+ * - Schema enum values are dynamically restricted to match detected capabilities
+ */
+exports.MIN_UI5_VERSION_FOR_TABLE_TYPE_RESTRICTIONS = '1.142.0';
+/**
+ * Returns true when the given manifest section object contains an `embeddedComponent` property,
+ * i.e. it is an HDM-style reuse component section rather than an XML-fragment custom section.
+ *
+ * @param section - The manifest section object to test.
+ * @returns `true` if the section has an `embeddedComponent` property.
+ */
+function hasEmbeddedComponent(section) {
+    return typeof section === 'object' && section !== null && ux_specification_types_1.TemplatePropertyName.EmbeddedComponent in section;
+}
+/**
+ * Table type options for UI5 versions before 1.142.0, where capability-based restrictions
+ * are not supported. All table types are available, with ResponsiveTable as the default.
+ */
+const LEGACY_VERSION_TABLE_TYPE_OPTIONS = {
+    options: [v4_1.TableTypeV4.ResponsiveTable, v4_1.TableTypeV4.GridTable, v4_1.TableTypeV4.AnalyticalTable, v4_1.TableTypeV4.TreeTable],
+    defaultType: v4_1.TableTypeV4.ResponsiveTable
+};
 exports.DATA_FIELD_FOR_ACTION_GROUP = 'DataFieldForActionGroup';
 const UI_ANNOTATION_KEY = 'UI';
 exports.FIELD_SEPARATOR = '::';
@@ -742,24 +815,31 @@ function addCustomColumnDefinition(appSchema, v4Page, logger, customColumnDefini
     appSchema.definitions[lineItemId].properties = sortedColumnsAsObject;
 }
 /**
- * Determines the appropriate action definition name based on the provided line item data and record type.
+ * Determines the appropriate action definition name based on the provided annotation data and record type.
  *
- * @param {LineItemDataForSchema} data - The schema data for the line item, including its identifier and metadata.
- * @param {DataFieldAbstractTypes} lineItemRecord - The record representing a data field or action within the line item.
+ * @param {AnnotationSchemaContext} data - The schema data for the annotation, including its identifier and metadata.
+ * @param {DataFieldAbstractTypes} annotationRecord - The record representing a data field or action within the annotation collection.
  * @param {boolean} isInnerAction - Whether the action belongs to the action group.
  * @returns {DefinitionName} The determined action definition name based on the provided data and group type.
  */
-function determineActionDefinitionName(data, lineItemRecord, isInnerAction) {
-    const isGrouped = lineItemRecord.$Type === "com.sap.vocabularies.UI.v1.DataFieldForActionGroup" /* UIAnnotationTypes.DataFieldForActionGroup */;
+function determineActionDefinitionName(data, annotationRecord, isInnerAction) {
+    const isGrouped = annotationRecord.$Type === "com.sap.vocabularies.UI.v1.DataFieldForActionGroup" /* UIAnnotationTypes.DataFieldForActionGroup */;
     let actionDefinitionName;
-    if (data.lineItemId.startsWith(ux_specification_types_1.DefinitionName.LineItemsOfView)) {
+    if (data.annotation['term'] === "com.sap.vocabularies.UI.v1.Chart" /* UIAnnotationTerms.Chart */) {
+        actionDefinitionName = isGrouped
+            ? ux_specification_types_1.DefinitionName.ViewToolBarActionGroup
+            : isInnerAction
+                ? ux_specification_types_1.DefinitionName.ViewToolBarActionBase
+                : ux_specification_types_1.DefinitionName.ChartToolBarAction;
+    }
+    else if (data.annotationId.startsWith(ux_specification_types_1.DefinitionName.LineItemsOfView)) {
         actionDefinitionName = isGrouped
             ? ux_specification_types_1.DefinitionName.ViewToolBarActionGroup
             : isInnerAction
                 ? ux_specification_types_1.DefinitionName.ViewToolBarActionBase
                 : ux_specification_types_1.DefinitionName.ViewToolBarAction;
     }
-    else if (data.lineItemId.startsWith(ux_specification_types_1.DefinitionName.LineItems)) {
+    else if (data.annotationId.startsWith(ux_specification_types_1.DefinitionName.LineItems)) {
         actionDefinitionName = isGrouped
             ? ux_specification_types_1.DefinitionName.ToolBarActionGroup
             : isInnerAction
@@ -797,32 +877,32 @@ function addTargetAndKeysOfAction(actionDefinition, lineItemRecord, actionId) {
     }
 }
 /**
- * Adds an action record to a schema definition based on the provided line item definition parameters.
+ * Adds an action record to a schema definition based on the provided annotation record definition parameters.
  * This involves defining action-specific properties, references, and metadata, and updating the schema accordingly.
  *
- * @param {AddLineItemDefinitionParams} lineItemDefinitionParams - The parameters describing the line item definition, including data, actions, path, record, and index.
+ * @param {AddAnnotationRecordDefinitionParams} annotationRecordParams - The parameters describing the annotation record definition, including data, actions, path, record, and index.
  * @param {boolean} [createRef] - A flag indicating whether to create a reference for the action definition.
  * @param {boolean} isInnerAction - Whether the action belongs to the action group.
  */
-function addActionRecordToSchema(lineItemDefinitionParams, createRef = true, isInnerAction = false) {
-    const { lineItemData: data, actions: actionsDefinition, lineItemPath, lineItemRecord, index: recordIndex } = lineItemDefinitionParams;
+function addActionRecordToSchema(annotationRecordParams, createRef = true, isInnerAction = false) {
+    const { schemaContext: data, actions: actionsDefinition, annotationPath, annotationRecord, index: recordIndex } = annotationRecordParams;
     // Action but not inline action
-    if (lineItemRecord.Determining === true) {
+    if (annotationRecord.Determining === true) {
         return;
     }
     //no footer bar -> toolbar action
-    const actionDefinitionName = determineActionDefinitionName(data, lineItemRecord, isInnerAction);
-    const description = (0, common_1.getDataFieldDescription)(lineItemRecord, data.entityType);
+    const actionDefinitionName = determineActionDefinitionName(data, annotationRecord, isInnerAction);
+    const description = (0, common_1.getDataFieldDescription)(annotationRecord, data.entityType);
     // Generate stable ID using strategy pattern to ensure correct key format for all action types.
     // This is crucial for IBN actions, which need the full key including SemanticObject and RequiresContext
     // (e.g., "DataFieldForIntentBasedNavigation::v4Freestyle::Inbound::RequiresContext")
     // to be properly matched when referenced in manifest-based action menus.
-    const strategy = DataFieldStrategy_1.dataFieldStrategyContext.getStrategy(lineItemRecord.$Type);
-    const stableId = strategy.generateStableId(lineItemRecord);
+    const strategy = DataFieldStrategy_1.dataFieldStrategyContext.getStrategy(annotationRecord.$Type);
+    const stableId = strategy.generateStableId(annotationRecord);
     // Extract Action property for keys generation (used by addTargetAndKeysOfAction).
     // For IBN actions, this is just the action name (e.g., "Inbound").
     // For bound actions, this may include namespace (e.g., "com.sap.Action/MyAction").
-    const actionId = typeof lineItemRecord.Action === 'string' ? lineItemRecord.Action : lineItemRecord.Action['path'];
+    const actionId = typeof annotationRecord.Action === 'string' ? annotationRecord.Action : annotationRecord.Action['path'];
     // Remove type prefix from stable ID for use in $ref generation.
     // This ensures getUniqueFacetDefinitionLink can properly detect duplicates based on full action identity,
     // not just the Action property. For example, two IBN actions with different SemanticObjects but same Action
@@ -834,7 +914,7 @@ function addActionRecordToSchema(lineItemDefinitionParams, createRef = true, isI
         description
     });
     if (createRef) {
-        actionDefinition.$ref = (0, common_1.getUniqueFacetDefinitionLink)(actionDefinitionName, (0, common_1.prepareRef)(stableIdWithoutPrefix), data.appSchema, lineItemPath);
+        actionDefinition.$ref = (0, common_1.getUniqueFacetDefinitionLink)(actionDefinitionName, (0, common_1.prepareRef)(stableIdWithoutPrefix), data.appSchema, annotationPath);
     }
     else {
         actionDefinition.properties = {};
@@ -842,38 +922,38 @@ function addActionRecordToSchema(lineItemDefinitionParams, createRef = true, isI
         actionDefinition.isViewNode = true;
     }
     actionDefinition[ux_specification_types_1.SchemaTag.propertyIndex] = recordIndex;
-    actionDefinition[ux_specification_types_1.SchemaTag.dataType] = (0, common_1.determineDataType)(lineItemRecord);
+    actionDefinition[ux_specification_types_1.SchemaTag.dataType] = (0, common_1.determineDataType)(annotationRecord);
     //keys
-    addTargetAndKeysOfAction(actionDefinition, lineItemRecord, actionId);
-    actionDefinition[ux_specification_types_1.SchemaTag.annotationType] = lineItemRecord.$Type;
+    addTargetAndKeysOfAction(actionDefinition, annotationRecord, actionId);
+    actionDefinition[ux_specification_types_1.SchemaTag.annotationType] = annotationRecord.$Type;
     if (createRef) {
         // Using previously computed ref instead of generating new one to support action duplication
         const previouslyComputedRef = actionDefinition.$ref.replace(utils_1.DEFINITION_LINK_PREFIX, '');
         const action = (0, common_1.parseSchemaDefinition)(actionDefinitionName, previouslyComputedRef, data.appSchema, false);
-        action[ux_specification_types_1.SchemaTag.annotationPath] = `${lineItemPath}/${recordIndex}`;
+        action[ux_specification_types_1.SchemaTag.annotationPath] = `${annotationPath}/${recordIndex}`;
     }
     else {
-        actionDefinition[ux_specification_types_1.SchemaTag.annotationPath] = `${lineItemPath}/${recordIndex}`;
+        actionDefinition[ux_specification_types_1.SchemaTag.annotationPath] = `${annotationPath}/${recordIndex}`;
     }
 }
 /**
  * Adds a group action record to the schema based on the given parameters. This involves determining
  * action definitions, creating or referencing schema properties, and setting metadata fields.
  *
- * @param {AddLineItemDefinitionParams} lineItemDefinitionParams - Parameters that define the line item, including data, record, path, index, and actions.
+ * @param {AddAnnotationRecordDefinitionParams} annotationRecordParams - Parameters that define the annotation record, including data, record, path, index, and actions.
  * @param {boolean} [createRef] - Indicates whether to create a reference for the action definition or to use an inline object.
  */
-function addGroupActionRecordToSchema(lineItemDefinitionParams, createRef = true) {
-    const { lineItemData, lineItemRecord, lineItemPath, index, actions } = lineItemDefinitionParams;
+function addGroupActionRecordToSchema(annotationRecordParams, createRef = true) {
+    const { schemaContext, annotationRecord, annotationPath, index, actions } = annotationRecordParams;
     //no footer bar -> toolbar action
-    const actionDefinitionName = determineActionDefinitionName(lineItemData, lineItemRecord);
-    const propertyKey = (0, StableIdHelper_1.getStableIdPartFromDataField)(lineItemRecord);
+    const actionDefinitionName = determineActionDefinitionName(schemaContext, annotationRecord);
+    const propertyKey = (0, StableIdHelper_1.getStableIdPartFromDataField)(annotationRecord);
     let actionDefinition = {};
     if (createRef) {
         actions.properties[`${propertyKey}`] = {
             $ref: (0, common_1.getFacetDefinitionLink)(actionDefinitionName, (0, common_1.prepareRef)(propertyKey))
         };
-        actionDefinition = (0, common_1.parseSchemaDefinition)(actionDefinitionName, (0, common_1.prepareRef)(propertyKey), lineItemData.appSchema);
+        actionDefinition = (0, common_1.parseSchemaDefinition)(actionDefinitionName, (0, common_1.prepareRef)(propertyKey), schemaContext.appSchema);
     }
     else {
         actions.properties[`${propertyKey}`] = actionDefinition;
@@ -881,115 +961,119 @@ function addGroupActionRecordToSchema(lineItemDefinitionParams, createRef = true
     if (!actionDefinition.properties) {
         actionDefinition.properties = {};
     }
-    actionDefinition.description = (0, common_1.getDataFieldDescription)(lineItemRecord, lineItemData.entityType);
+    actionDefinition.description = (0, common_1.getDataFieldDescription)(annotationRecord, schemaContext.entityType);
     actionDefinition.type = 'object';
     actionDefinition.isViewNode = true;
     actionDefinition[ux_specification_types_1.SchemaTag.propertyIndex] = index;
-    actionDefinition[ux_specification_types_1.SchemaTag.dataType] = (0, common_1.determineDataType)(lineItemRecord);
-    actionDefinition[ux_specification_types_1.SchemaTag.annotationPath] = `${lineItemPath}/${index}`;
-    (lineItemRecord['Actions'] ?? []).forEach((action, index) => {
-        const lineItemActionDefinitionParams = {
-            ...lineItemDefinitionParams,
-            lineItemRecord: action,
-            lineItemPath: `${actionDefinition[ux_specification_types_1.SchemaTag.annotationPath]}/Actions`,
+    actionDefinition[ux_specification_types_1.SchemaTag.dataType] = (0, common_1.determineDataType)(annotationRecord);
+    actionDefinition[ux_specification_types_1.SchemaTag.annotationPath] = `${annotationPath}/${index}`;
+    (annotationRecord['Actions'] ?? []).forEach((action, index) => {
+        const innerActionParams = {
+            ...annotationRecordParams,
+            annotationRecord: action,
+            annotationPath: `${actionDefinition[ux_specification_types_1.SchemaTag.annotationPath]}/Actions`,
             actions: actionDefinition,
             index
         };
-        addActionRecordToSchema(lineItemActionDefinitionParams, createRef, true);
+        addActionRecordToSchema(innerActionParams, createRef, true);
     });
 }
 /**
  * Adds a line item action definition to the schema based on the provided parameters.
- * Handles determining which action to take based on specific conditions of the line item record.
+ * Handles determining which action to take based on specific conditions of the annotation record.
  *
- * @param {AddLineItemDefinitionParams} data - An object containing the details of the line item record and the line item definition.
- * @param {object} data.lineItemRecord - The record of the line item to be processed, containing relevant properties.
- * @param {boolean} data.lineItemRecord.Inline - Indicates whether the line item is inline.
- * @param {boolean} data.lineItemRecord.Determining - Indicates if the line item is determining.
- * @param {boolean} data.lineItemDefinition - Indicates whether the line item definition is present.
+ * @param {AddAnnotationRecordDefinitionParams} annotationRecordParams - An object containing the details of the annotation record and the inline definition.
+ * @param {object} annotationRecordParams.annotationRecord - The annotation record to be processed, containing relevant properties.
+ * @param {boolean} annotationRecordParams.annotationRecord.Inline - Indicates whether the record is inline.
+ * @param {boolean} annotationRecordParams.annotationRecord.Determining - Indicates if the record is determining.
+ * @param {boolean} annotationRecordParams.inlineDefinition - Indicates whether the inline definition is present.
  */
-function addLineItemActionDefinition(data) {
-    const { lineItemRecord, lineItemDefinition } = data;
-    if (lineItemRecord.Inline !== true || lineItemRecord.Determining === true) {
-        addActionRecordToSchema(data, !lineItemDefinition);
+function addLineItemActionDefinition(annotationRecordParams) {
+    const { annotationRecord, inlineDefinition } = annotationRecordParams;
+    if (annotationRecord.Inline !== true || annotationRecord.Determining === true) {
+        addActionRecordToSchema(annotationRecordParams, !inlineDefinition);
     }
     else {
-        addLineItemRecordToSchema(data);
+        addLineItemRecordToSchema(annotationRecordParams);
     }
 }
 /**
  * Adds a line item record to the provided schema based on the definition parameters.
  *
- * @param {AddLineItemDefinitionParams} lineItemDefinitionParams - The parameters defining the line item data, schema information, and record.
+ * @param {AddAnnotationRecordDefinitionParams} annotationRecordParams - The parameters defining the annotation data, schema information, and record.
  */
-function addLineItemRecordToSchema(lineItemDefinitionParams) {
-    const { lineItemData, lineItemRecord, lineItemDefinition, lineItemPath, index, columnDefinitionName } = lineItemDefinitionParams;
-    const columnDefinition = lineItemRecord.$Type === "com.sap.vocabularies.UI.v1.DataFieldForAction" /* UIAnnotationTypes.DataFieldForAction */
-        ? `${columnDefinitionName}Action`
-        : columnDefinitionName;
-    const lineItemId = lineItemData.lineItemId;
-    if (lineItemRecord['Target']?.['value']) {
-        const regex = `@${(0, utils_1.findAlias)(ux_specification_types_1.UIVOCABULARY, lineItemData.oDataServiceAVT)}.`;
-        lineItemRecord['Target']['value'] = lineItemRecord['Target']['value'].replace(regex, '@');
+function addLineItemRecordToSchema(annotationRecordParams) {
+    const { schemaContext, annotationRecord, inlineDefinition, annotationPath, index, definitionName } = annotationRecordParams;
+    let columnDefinition;
+    if (definitionName) {
+        columnDefinition =
+            annotationRecord.$Type === "com.sap.vocabularies.UI.v1.DataFieldForAction" /* UIAnnotationTypes.DataFieldForAction */
+                ? `${definitionName}Action`
+                : definitionName;
+    }
+    const lineItemId = schemaContext.annotationId;
+    if (annotationRecord['Target']?.['value']) {
+        const regex = `@${(0, utils_1.findAlias)(ux_specification_types_1.UIVOCABULARY, schemaContext.oDataServiceAVT)}.`;
+        annotationRecord['Target']['value'] = annotationRecord['Target']['value'].replace(regex, '@');
     }
-    const schemaKey = (0, StableIdHelper_1.getStableIdPartFromDataField)(lineItemRecord).replace(/\//g, exports.FIELD_SEPARATOR);
+    const schemaKey = (0, StableIdHelper_1.getStableIdPartFromDataField)(annotationRecord).replace(/\//g, exports.FIELD_SEPARATOR);
     if (schemaKey) {
-        let columnsDefinition = lineItemDefinition;
+        let columnsDefinition = inlineDefinition;
         if (!columnsDefinition) {
-            columnsDefinition = lineItemData.appSchema.definitions[lineItemId];
+            columnsDefinition = schemaContext.appSchema.definitions[lineItemId];
         }
         const properties = columnsDefinition.properties;
         const property = {
-            description: (0, common_1.getDataFieldDescription)(lineItemRecord, lineItemData.entityType)
+            description: (0, common_1.getDataFieldDescription)(annotationRecord, schemaContext.entityType)
         };
-        if (lineItemDefinition) {
+        if (inlineDefinition) {
             property.properties = {};
             property.type = 'object';
             property.isViewNode = true;
         }
-        else {
+        else if (columnDefinition) {
             property.$ref = utils_1.DEFINITION_LINK_PREFIX + columnDefinition;
         }
-        property[ux_specification_types_1.SchemaTag.annotationType] = lineItemRecord?.$Type;
-        property[ux_specification_types_1.SchemaTag.annotationPath] = `${lineItemPath}/${index}`;
+        property[ux_specification_types_1.SchemaTag.annotationType] = annotationRecord?.$Type;
+        property[ux_specification_types_1.SchemaTag.annotationPath] = `${annotationPath}/${index}`;
         property[ux_specification_types_1.SchemaTag.propertyIndex] = index;
-        property[ux_specification_types_1.SchemaTag.dataType] = (0, common_1.determineDataType)(lineItemRecord);
+        property[ux_specification_types_1.SchemaTag.dataType] = (0, common_1.determineDataType)(annotationRecord);
         properties[schemaKey] = property;
-        (0, common_1.addKeyToDefinition)(lineItemRecord, properties, schemaKey);
+        (0, common_1.addKeyToDefinition)(annotationRecord, properties, schemaKey);
     }
 }
 /**
- * Appends line item columns and actions to the app schema (for the list report, custom page or an object page section comprising a table).
+ * Appends annotation record columns and actions to the app schema (for the list report, custom page or an object page section comprising a table).
  *
- * @param {LineItemDataForSchema} data structure comprising
+ * @param {AnnotationSchemaContext} data structure comprising
  * - appSchema - the app specific schema that shall get enhanced
- * - lineItemAnnotation - the UI.LineItem annotation, comprising all records
+ * - annotation - the UI.LineItem annotation, comprising all records
  * - entityType - the entity type as part of the AVT ConvertedMetadata
  * - oDataServiceAVT - complete service information, as returned by Annotation Vocabularies Tool
- * - lineItemId - in case of OP the parameter must be passed to distinguish the OP tables;
- *                in case of LR or ALP 'LineItems' is passed.
+ * - annotationId - in case of OP the parameter must be passed to distinguish the OP tables;
+ *                  in case of LR or ALP 'LineItems' is passed.
  * @param {Definition} actions - actions definition in schema, parent object
  * @param {string} lineItemPath - annotation path to the line item
  * @param {Definition | undefined} lineItemDefinition - line item definition
  * @param {string} columnDefinitionName - line item definition name
  */
 function appendLineItemsToSchema(data, actions, lineItemPath, lineItemDefinition, columnDefinitionName = ux_specification_types_1.DefinitionName.TableColumn) {
-    if (!data.lineItemAnnotation) {
+    if (!data.annotation) {
         return;
     }
     let i = 0;
-    data.lineItemAnnotation.forEach((lineItemRecord) => {
-        const addLineItemDefinitionsParams = {
-            lineItemData: data,
+    data.annotation.forEach((lineItemRecord) => {
+        const params = {
+            schemaContext: data,
             actions,
-            lineItemPath,
-            lineItemRecord: lineItemRecord,
+            annotationPath: lineItemPath,
+            annotationRecord: lineItemRecord,
             index: i,
-            lineItemDefinition,
-            columnDefinitionName
+            inlineDefinition: lineItemDefinition,
+            definitionName: columnDefinitionName
         };
         const strategy = DataFieldStrategy_1.dataFieldStrategyContext.getStrategy(lineItemRecord.$Type);
-        strategy.addLineItemDefinition(addLineItemDefinitionsParams);
+        strategy.addLineItemDefinition(params);
         i++;
     });
 }
@@ -999,17 +1083,17 @@ function appendLineItemsToSchema(data, actions, lineItemPath, lineItemDefinition
  * @param data structure comprising
  * - isObjectPage - indicates that the page is an object page
  * - appSchema - the app specific schema that shall get enhanced
- * - lineItemAnnotation - the UI.LineItem annotation, comprising all records
+ * - annotation - the UI.LineItem annotation, comprising all records
  * - entityType - the entity type as part of the AVT ConvertedMetadata
  * - oDataServiceAVT - complete service information, as returned by Annotation Vocabularies Tool
- * - lineItemId - in case of OP the parameter must be passed to distinguish the OP tables;
+ * - annotationId - in case of OP the parameter must be passed to distinguish the OP tables;
  *                in case of LR or ALP 'LineItems' is passed.
  * @param columnDefinitionName - name of the column definition, i.e. TableColumn or ObjectPageTableColumn
  * @param customColumnDefinitionName - name of the custom column definition
  * @param customActionDefinitionName - name of the custom action definition
  */
 function addLineItemsTypeToSchema(data, columnDefinitionName = ux_specification_types_1.DefinitionName.TableColumn, customColumnDefinitionName = ux_specification_types_1.DefinitionName.CustomColumn, customActionDefinitionName = ux_specification_types_1.DefinitionName.CustomTableAction) {
-    const { actions, lineItemPath } = (0, common_1.addCommonLineItemDefinitions)(data.isObjectPage, data.appSchema, data.lineItemAnnotation, data.entityType, data.lineItemId, customColumnDefinitionName, customActionDefinitionName);
+    const { actions, lineItemPath } = (0, common_1.addCommonLineItemDefinitions)(data.isObjectPage, data.appSchema, data.annotation, data.entityType, data.annotationId, customColumnDefinitionName, customActionDefinitionName);
     appendLineItemsToSchema(data, actions, lineItemPath, undefined, columnDefinitionName);
 }
 /**
@@ -1704,11 +1788,11 @@ function addCustomSectionDefinition(appSchema, definition, v4Page, customSection
         }
     }
     else {
-        // body custom section extensions
+        // body custom section extensions — accept both fragment-based (template) and
+        // embeddedComponent-based (e.g. HDM attachment reuse) sections
         const sections = v4Page.options?.settings?.content?.body?.sections;
         if (sections) {
-            // add extension to sections section
-            sortedSectionsArray = addExtensionToArray(sections, sortedSectionsArray, customSectionRef, ux_specification_types_1.TemplatePropertyName.Template, logger, isMergedSections);
+            sortedSectionsArray = addExtensionToArray(sections, sortedSectionsArray, customSectionRef, [ux_specification_types_1.TemplatePropertyName.Template, ux_specification_types_1.TemplatePropertyName.EmbeddedComponent], logger, isMergedSections);
         }
     }
     // Adjust propertyIndex
@@ -1995,6 +2079,195 @@ function getInsertableForEntitySet(entitySet, navigationPath) {
     }
     return entitySetInsertable;
 }
+/**
+ * Determines the default OData V4 table type for an entity set based on its metadata capabilities.
+ *
+ * The decision follows a strict priority order:
+ * 1) Analytical tables take precedence when aggregate transformations are present and the
+ *    analytical requirements are satisfied.
+ * 2) Hierarchical tables are selected when a recursive hierarchy is defined and analytical
+ *    conditions are not met.
+ * 3) Responsive tables are used as a safe fallback when neither analytical nor hierarchical
+ *    characteristics apply.
+ *
+ * The evaluation of analytical suitability differs between CAP and non-CAP services:
+ * - **CAP services**: Require both service-level AND entity-level aggregation annotations.
+ * - **Non-CAP services**: Service-level aggregation annotations are sufficient.
+ *
+ * @param entitySet The entity set whose annotations are evaluated.
+ * @param isCapService Indicates whether the service is a CAP service, affecting analytical requirements.
+ * @returns The default {@link TableTypeV4} to be used for the entity set.
+ */
+function getDefaultTableType(entitySet, isCapService) {
+    if (!entitySet) {
+        // Fallback when entitySet is not provided
+        return FALLBACK_TABLE_TYPE;
+    }
+    const { hasRecursiveHierarchyForEntitySet, hasAggregateTransformations, hasAggregateTransformationsForEntitySet } = (0, project_access_1.getTableCapabilitiesByEntitySet)(entitySet);
+    // Check for analytical capabilities first (highest priority)
+    // Requires service-level aggregate transformations (hasAggregateTransformations) as a prerequisite
+    // For CAP services: both service-level and entity-level transformations must be present
+    // For non-CAP services: service-level transformations alone are sufficient
+    if (hasAggregateTransformations && (hasAggregateTransformationsForEntitySet || !isCapService)) {
+        return v4_1.TableTypeV4.AnalyticalTable;
+    }
+    // Check for hierarchical data only (no analytical data or analytical requirements not met)
+    if (hasRecursiveHierarchyForEntitySet) {
+        return v4_1.TableTypeV4.TreeTable;
+    }
+    // Default for standard entity sets without analytical or hierarchical capabilities
+    return v4_1.TableTypeV4.ResponsiveTable;
+}
+/**
+ * Determines the available table type options and recommended default type for an entity set
+ * based on its metadata capabilities.
+ *
+ * This function analyzes the entity set's capabilities and returns both the list of suitable
+ * table types and the recommended default type. The available options are restricted based
+ * on the detected service characteristics:
+ *
+ * - **Analytical services**: AnalyticalTable, ResponsiveTable, GridTable (default: AnalyticalTable).
+ * - **Hierarchical services**: TreeTable, ResponsiveTable, GridTable (default: TreeTable).
+ * - **Standard services**: ResponsiveTable, GridTable (default: ResponsiveTable).
+ *
+ * **Version gating**: Capability-based restrictions are only applied for UI5 1.142.0+.
+ * For earlier versions, all table types are available (ResponsiveTable, GridTable, AnalyticalTable, TreeTable)
+ * with ResponsiveTable as the default.
+ *
+ * @param entitySet The entity set whose capabilities determine the available table types.
+ * @param isCapService Indicates whether the service is a CAP service, affecting analytical
+ *                     capability detection.
+ * @param minUI5Version The minimum UI5 version from manifest. Capability-based restrictions
+ *                      require UI5 1.142.0+.
+ * @returns An object containing:
+ *          - `options`: Array of suitable {@link TableTypeV4} values for the entity set
+ *          - `defaultType`: The recommended {@link TableTypeV4} as the default choice
+ * @example
+ * // For an entity set with analytical capabilities (UI5 1.142+)
+ * const result = getTableTypeOptions(analyticalEntitySet, true, '1.142.0');
+ * // Returns: { options: [AnalyticalTable, ResponsiveTable, GridTable], defaultType: AnalyticalTable }
+ *
+ * // For the same entity set on UI5 1.120 (all types available, no restrictions)
+ * const result = getTableTypeOptions(analyticalEntitySet, true, '1.120.0');
+ * // Returns: { options: [ResponsiveTable, GridTable, AnalyticalTable, TreeTable], defaultType: ResponsiveTable }
+ */
+function getTableTypeOptions(entitySet, isCapService, minUI5Version) {
+    // Capability-based restrictions are only available in UI5 1.142.0+
+    // For earlier versions, all table types are available
+    if (minUI5Version && !(0, utils_3.compareUI5Versions)(minUI5Version, exports.MIN_UI5_VERSION_FOR_TABLE_TYPE_RESTRICTIONS)) {
+        return LEGACY_VERSION_TABLE_TYPE_OPTIONS;
+    }
+    const detectedType = getDefaultTableType(entitySet, isCapService);
+    return TABLE_TYPE_OPTIONS_MAP[detectedType];
+}
+/**
+ * Creates a virtual EntitySet for capability detection when the entitySet.entityType
+ * doesn't match the actual target EntityType (e.g., for contained navigation).
+ *
+ * This is needed for contained navigation (ContainsTarget=true) where there is no
+ * physical EntitySet in the metadata, but the target EntityType has important
+ * annotations like RecursiveHierarchy.
+ *
+ * @param entitySet - The base entity set (may have wrong entityType for contained navigation)
+ * @param targetEntityType - The actual entity type with correct annotations
+ * @returns EntitySet with correct entityType for capability detection, or original if types match
+ * @example
+ * // For contained navigation "/ZZZC_FINANCIAL_TREE/Set"
+ * const entitySetForCapabilities = ensureEntitySetWithCorrectType(
+ *     entitySet,              // ZZZC_FINANCIAL_TREE (type: Parameters)
+ *     lineItemFacet.entityType // ZZZC_FINANCIAL_TREEType (with RecursiveHierarchy)
+ * );
+ * const options = getTableTypeOptions(entitySetForCapabilities, isCapService);
+ */
+function ensureEntitySetWithCorrectType(entitySet, targetEntityType) {
+    if (!entitySet || !targetEntityType) {
+        return entitySet;
+    }
+    // If entityType already matches, return as-is
+    if (entitySet.entityType === targetEntityType) {
+        return entitySet;
+    }
+    // Create virtual EntitySet with correct entityType and its annotations
+    return {
+        ...entitySet,
+        entityType: targetEntityType,
+        annotations: targetEntityType.annotations || entitySet.annotations
+    };
+}
+/**
+ * Returns the appropriate fallback table type options based on UI5 version.
+ * For UI5 < 1.142.0, returns all table types (legacy behavior).
+ * For UI5 >= 1.142.0, returns restricted fallback options.
+ *
+ * @param minUI5Version - Optional minimum UI5 version
+ * @returns Table type options with all types for legacy versions, or restricted options for modern versions
+ */
+function getFallbackTableTypeOptions(minUI5Version) {
+    if (minUI5Version && !(0, utils_3.compareUI5Versions)(minUI5Version, exports.MIN_UI5_VERSION_FOR_TABLE_TYPE_RESTRICTIONS)) {
+        return LEGACY_VERSION_TABLE_TYPE_OPTIONS;
+    }
+    return FALLBACK_TABLE_TYPE_OPTIONS;
+}
+/**
+ * Determines table type options based on context path by resolving the entity set internally.
+ *
+ * This is a wrapper function that handles the complexity of entity set resolution from annotation files.
+ * It parses the annotation files, resolves the entity set from the context path, and returns the
+ * appropriate table type options.
+ *
+ * **Version gating**: Capability-based restrictions are only applied for UI5 1.142.0+.
+ * For earlier versions, all table types are available.
+ *
+ * @param annotationFiles - Array of annotation files containing metadata
+ * @param contextPath - Context path or navigation property. Can be:
+ *                      - Full path starting with "/" (e.g., "/Travel", "/Travel/to_Booking")
+ *                      - Navigation property without "/" (e.g., "to_Booking") - requires entitySetName
+ *                      - Entity set name (e.g., "Travel")
+ * @param entitySetName - Optional entity set name. Required when contextPath is a navigation property without "/"
+ * @param isCapService - Indicates whether the service is a CAP service
+ * @param logger - Optional logger for debugging
+ * @param minUI5Version - Optional minimum UI5 version. Capability-based restrictions require UI5 1.142.0+
+ * @returns An object containing:
+ *          - `options`: Array of suitable {@link TableTypeV4} values for the entity set
+ *          - `defaultType`: The recommended {@link TableTypeV4} as the default choice
+ * @example
+ * // For an analytical service with full path (UI5 1.142+)
+ * const result = getTableTypeOptionsByContext(annotationFiles, "/Travel/to_Booking", undefined, true, logger, '1.142.0');
+ * // Returns: { options: [AnalyticalTable, ResponsiveTable, GridTable], defaultType: AnalyticalTable }
+ * @example
+ * // For navigation property with entity set name (UI5 1.120)
+ * const result = getTableTypeOptionsByContext(annotationFiles, "to_Booking", "Travel", true, logger, '1.120.0');
+ * // Returns: { options: [ResponsiveTable, GridTable, AnalyticalTable, TreeTable], defaultType: ResponsiveTable }
+ */
+function getTableTypeOptionsByContext(annotationFiles, contextPath, entitySetName, isCapService, logger, minUI5Version) {
+    try {
+        // 1. Parse and convert annotation files to ConvertedMetadata
+        const convertedMetadata = (0, utils_1.parseAndMergeAndConvert)(annotationFiles, logger);
+        if (!convertedMetadata) {
+            logger?.info('Could not parse annotation files, returning default table type options');
+            return getFallbackTableTypeOptions(minUI5Version);
+        }
+        // 2. Build full context path if needed
+        // If contextPath doesn't start with "/" and entitySetName is provided, combine them
+        let fullContextPath = contextPath;
+        if (entitySetName && contextPath && !contextPath.startsWith('/')) {
+            fullContextPath = `/${entitySetName}/${contextPath}`;
+        }
+        // 3. Resolve entity set from context path
+        const { entitySet } = (0, importProject_1.getEntityTypeEntitySetFromContextPath)(convertedMetadata, fullContextPath, entitySetName, logger);
+        if (!entitySet) {
+            logger?.info(`Could not resolve entity set for context path: ${fullContextPath}, returning default table type options`);
+            return getFallbackTableTypeOptions(minUI5Version);
+        }
+        // 4. Call existing getTableTypeOptions with resolved entitySet
+        return getTableTypeOptions(entitySet, isCapService, minUI5Version);
+    }
+    catch (error) {
+        logger?.error('Error in getTableTypeOptionsByContext', error);
+        // Fallback to default options on error
+        return getFallbackTableTypeOptions(minUI5Version);
+    }
+}
 /**
  * Returns the manifest path for a given page based on the provided path parameters.
  *