@sap/ux-specification 1.142.0 → 1.142.2

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

@@ -55,11 +55,15 @@ exports.findPageV4 = findPageV4;
 exports.alignSchemaWithTemplateType = alignSchemaWithTemplateType;
 exports.addCustomActionDefinition = addCustomActionDefinition;
 exports.addHeaderFooterCustomActionDefinition = addHeaderFooterCustomActionDefinition;
+exports.parseDefinitionName = parseDefinitionName;
 exports.getManifestPage = getManifestPage;
 exports.getPageCustomExtensionFile = getPageCustomExtensionFile;
 exports.getPageCustomViewFile = getPageCustomViewFile;
 exports.addCustomSectionDefinition = addCustomSectionDefinition;
 exports.addCustomFilterFieldDefinition = addCustomFilterFieldDefinition;
+exports.importSingleActionSettingsOfReference = importSingleActionSettingsOfReference;
+exports.importGroupActionSettingsOfReference = importGroupActionSettingsOfReference;
+exports.importManifestBasedActionMenuSettingsOfReference = importManifestBasedActionMenuSettingsOfReference;
 exports.importActionSettingsOfReference = importActionSettingsOfReference;
 exports.addCustomFieldDefinition = addCustomFieldDefinition;
 exports.addManifestPathsToProperties = addManifestPathsToProperties;
@@ -80,6 +84,36 @@ exports.DATA_FIELD_FOR_ACTION_GROUP = 'DataFieldForActionGroup';
 const UI_ANNOTATION_KEY = 'UI';
 exports.FIELD_SEPARATOR = '::';
 exports.QUALIFIER_SEPARATOR = '#';
+const ACTION_TYPE = 'actionType';
+const strategyTypeMap = new Map([
+    ['', "com.sap.vocabularies.UI.v1.DataFieldForAction" /* UIAnnotationTypes.DataFieldForAction */],
+    ['DataFieldForAction', "com.sap.vocabularies.UI.v1.DataFieldForAction" /* UIAnnotationTypes.DataFieldForAction */],
+    ['DataFieldForActionGroup', "com.sap.vocabularies.UI.v1.DataFieldForActionGroup" /* UIAnnotationTypes.DataFieldForActionGroup */],
+    ['CustomMenu', ux_specification_types_1.CustomUIAnnotationTypes.ManifestBasedActionMenu]
+]);
+const OP_ACTION_MENU_DEFINITION = {
+    actionMenuDefinitionName: ux_specification_types_1.DefinitionName.ObjectPageCustomActionMenu,
+    actionMenuActionsDefinitionName: ux_specification_types_1.DefinitionName.ObjectPageCustomActionMenuActions
+};
+const OP_HEADER_ACTION_MENU_DEFINITION = {
+    actionMenuDefinitionName: ux_specification_types_1.DefinitionName.ObjectPageHeaderCustomActionMenu,
+    actionMenuActionsDefinitionName: ux_specification_types_1.DefinitionName.ObjectPageHeaderCustomActionMenuActions
+};
+const LR_ACTION_MENU_DEFINITION = {
+    actionMenuDefinitionName: ux_specification_types_1.DefinitionName.CustomActionMenu,
+    actionMenuActionsDefinitionName: ux_specification_types_1.DefinitionName.CustomActionMenuActions
+};
+const LR_ACTION_VIEW_MENU_DEFINITION = {
+    actionMenuDefinitionName: ux_specification_types_1.DefinitionName.ViewCustomActionMenu,
+    actionMenuActionsDefinitionName: ux_specification_types_1.DefinitionName.ViewCustomActionMenuActions
+};
+const actionMenuDefinitionNameMap = new Map([
+    [ux_specification_types_1.DefinitionName.CustomTableActionOP, OP_ACTION_MENU_DEFINITION],
+    [ux_specification_types_1.DefinitionName.CustomFormActionOP, OP_ACTION_MENU_DEFINITION],
+    [ux_specification_types_1.DefinitionName.CustomTableAction, LR_ACTION_MENU_DEFINITION],
+    [ux_specification_types_1.DefinitionName.CustomHeaderActionOP, OP_HEADER_ACTION_MENU_DEFINITION],
+    [ux_specification_types_1.DefinitionName.ViewCustomAction, LR_ACTION_VIEW_MENU_DEFINITION]
+]);
 /**
  * Returns a comparator function to sort objects by their property index.
  *
@@ -194,18 +228,24 @@ function getExtensionDetails(extension, extensionDefinitionName, extId, actionTy
 /**
  * Post-processing of custom extensions that are left after the first loop of adding extensions, i.e. custom extensions referring to other custom extensions.
  *
- * @param remainingExtensions - list of custom extensions that are left for post-processing
- * @param extensionDefinitionName - custom extension definition name, different in LR and OP
- * @param sortedExtArray - sorted array of annotation-based extensions, to be updated
- * @param logger - logger for error messages
- * @param {boolean} forceAdd - add self-referencing custom extensions after other additions
+ * @param {CustomExtensions} remainingExtensions - An object containing the remaining extensions to process.
+ * @param {string} extensionDefinitionName - The name of the extension definition to refer to.
+ * @param {[string, unknown][]} sortedExtArray - A sorted array of existing extensions represented as key-value pairs.
+ * @param {ExtensionLogger} logger - The logger used for logging errors and warnings during the adjustment process.
+ * @param {boolean} [forceAdd=false] - Flag indicating whether to force adding extensions even if proper anchor/placement is not found.
  */
 function adjustCustomExtReferringToCustomExt(remainingExtensions, extensionDefinitionName, sortedExtArray, logger, forceAdd = false) {
     const initialRemaining = Object.entries(remainingExtensions).length;
     for (const extId of Object.keys(remainingExtensions)) {
+        // make sure that we do not add the same extension twice
+        const isAlreadyAdded = sortedExtArray.find((element) => element[0] === extId) !== undefined;
+        if (isAlreadyAdded) {
+            delete remainingExtensions[extId];
+            continue;
+        }
         const extension = remainingExtensions[extId];
         // Detect description based on extension in manifest
-        const newCustomExt = getExtensionDetails(extension, extensionDefinitionName, extId);
+        const newCustomExt = getExtensionDetails(extension, extensionDefinitionName, extId, ux_specification_types_1.ActionType.Custom);
         if (extension.position?.anchor && extension.position?.placement) {
             const targetIndex = sortedExtArray.findIndex((element) => element[0] === extension.position.anchor);
             if (targetIndex > -1) {
@@ -365,17 +405,20 @@ function handleInvalidExtension(logger, extensionId, sortedExtensionsArray, newE
     delete localExtensions[extensionId];
 }
 /**
- * Adds extension at the right position of the sorted array of annotation-based nodes.
+ * Adds extension entries to a sorted array of extensions based on specific rules,
+ * including using anchors, callbacks, and custom templates.
  *
- * @param extensions - list of extensions in manifest
- * @param sortedExtensionsArray - sorted array of annotation-based nodes, to be enhanced by extensions
- * @param extensionDefinitionName - extension definition name, different in LR and OP
- * @param templatePropertyName - The name of the property in the template to be used for processing.
- * @param logger - logger for error messages
- * @param ignoreAnnotationAnchors - calculation should ignore anchors referenced to annotation nodes. Used when annotations sections are merged.
- * @returns Sorted array of annotation-based nodes, enhanced by extensions
+ * @param {CustomExtensions} extensions - The object containing custom extensions to be added to the array.
+ * @param {ActionDetails[]} sortedExtensionsArray - The array of sorted extensions to which new extensions will be added.
+ * @param {string} extensionDefinitionName - The definition name associated with the extensions being added.
+ * @param {TemplatePropertyName | TemplatePropertyName[]} [templatePropertyName=TemplatePropertyName.Template] -
+ * The property name(s) to check for existence in an extension; used to determine compatibility.
+ * @param {ExtensionLogger} [logger] - An optional logger to handle logging of invalid extensions or other events.
+ * @param {boolean} [ignoreAnnotationAnchors=false] - A flag to indicate whether extension anchors should be ignored.
+ * @returns {ActionDetails[]} The updated sorted extensions array, including newly added and valid extensions.
  */
-function addExtensionToArray(extensions, sortedExtensionsArray, extensionDefinitionName, templatePropertyName = 'template', logger, ignoreAnnotationAnchors = false) {
+function addExtensionToArray(extensions, sortedExtensionsArray, extensionDefinitionName, templatePropertyName = ux_specification_types_1.TemplatePropertyName.Template, logger, ignoreAnnotationAnchors = false) {
+    templatePropertyName = Array.isArray(templatePropertyName) ? templatePropertyName : [templatePropertyName];
     const annotationEntries = [...sortedExtensionsArray];
     const localExtensions = { ...extensions };
     const localExtensionsToSkip = getLocalExtensionsToSkip(localExtensions, annotationEntries);
@@ -392,7 +435,8 @@ function addExtensionToArray(extensions, sortedExtensionsArray, extensionDefinit
             handleInvalidExtension(logger, extensionId, sortedExtensionsArray, newExtensionReference, localExtensions);
             continue;
         }
-        if (!(templatePropertyName in extension)) {
+        const hasUnsupportedExtensionType = templatePropertyName.every((propertyName) => !(propertyName in extension));
+        if (hasUnsupportedExtensionType) {
             // Skip regular entries(columns, actions, etc.)
             delete localExtensions[extensionId];
             continue;
@@ -413,7 +457,7 @@ function addExtensionToArray(extensions, sortedExtensionsArray, extensionDefinit
     }
     if (Object.keys(localExtensions).length > 0) {
         //Second loop is necessary for custom columns that refer to custom columns
-        adjustCustomExtReferringToCustomExt(localExtensions, extensionDefinitionName, sortedExtensionsArray, logger);
+        adjustCustomExtReferringToCustomExt(localExtensions, extensionDefinitionName, sortedExtensionsArray, logger, false);
     }
     return sortedExtensionsArray;
 }
@@ -608,7 +652,6 @@ function addTargetAndKeysOfAction(actionDefinition, lineItemRecord, actionId) {
  * @param {AddLineItemDefinitionParams} lineItemDefinitionParams - The parameters describing the line item 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.
- * @returns {void} This function does not return a value.
  */
 function addActionRecordToSchema(lineItemDefinitionParams, createRef = true, isInnerAction = false) {
     const { lineItemData: data, actions: actionsDefinition, lineItemPath, lineItemRecord, index: recordIndex } = lineItemDefinitionParams;
@@ -654,7 +697,6 @@ function addActionRecordToSchema(lineItemDefinitionParams, createRef = true, isI
  *
  * @param {AddLineItemDefinitionParams} lineItemDefinitionParams - Parameters that define the line item, 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.
- * @returns {void} - Does not return any value.
  */
 function addGroupActionRecordToSchema(lineItemDefinitionParams, createRef = true) {
     const { lineItemData, lineItemRecord, lineItemPath, index, actions } = lineItemDefinitionParams;
@@ -700,7 +742,6 @@ function addGroupActionRecordToSchema(lineItemDefinitionParams, createRef = true
  * @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.
- * @returns {void} This method does not return a value.
  */
 function addLineItemActionDefinition(data) {
     const { lineItemRecord, lineItemDefinition } = data;
@@ -715,7 +756,6 @@ function addLineItemActionDefinition(data) {
  * 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.
- * @returns {void} This function does not return a value.
  */
 function addLineItemRecordToSchema(lineItemDefinitionParams) {
     const { lineItemData, lineItemRecord, lineItemDefinition, lineItemPath, index, columnDefinitionName } = lineItemDefinitionParams;
@@ -862,7 +902,6 @@ function addEnumForActionAnchor(appSchema, definitionId, positionName = ux_speci
  * @param {string} tableDefinitionName - The name of the table definition in the schema.
  * @param {string} columnsDefinitionName - The name of the columns definition used to extract column enumerations.
  * @param {EntityType} [entityType] - Optional entity type for additional context when retrieving column definitions.
- * @returns {void} No return value as this function modifies the schema in place.
  */
 function addEnumForEnableMassEdit(appSchema, tableDefinitionName, columnsDefinitionName, entityType) {
     const FIELD_PROPERTIES = ['visibleFields', 'ignoredFields'];
@@ -920,7 +959,10 @@ function initializeCreationModeSchema(appSchema, lineItemId, entityType, definit
     const specificCreationModeDefinitionName = (0, common_1.getFacetDefinitionKey)(definitionName, lineItemId);
     const specificCreationModeDefinition = (appSchema.definitions[specificCreationModeDefinitionName] = structuredClone(appSchema.definitions[definitionName]));
     const creationFieldsDefinition = specificCreationModeDefinition.properties[ux_specification_types_1.PropertyName.creationFields];
-    creationFieldsDefinition.items['oneOf'] = [...columnOneOfEnums, ...fieldGroups];
+    const creationFieldsDefinitionItems = creationFieldsDefinition.items;
+    creationFieldsDefinitionItems['oneOf'] = [...columnOneOfEnums, ...fieldGroups];
+    // Entries of one of are translatable using 'service' i18n bundle
+    creationFieldsDefinitionItems.i18nBundle = 'service';
     creationFieldsDefinition.uniqueItems = true;
     return specificCreationModeDefinitionName;
 }
@@ -978,13 +1020,13 @@ function findPageV4(pages, templateName, entitySet, contextPath) {
  * Depending on the template type, strip down the app schema so that only the relevant views are part of it.
  *
  * @param {Definition} appSchema - app specific JSON schema, to be adjusted
- * @param {GenerateAppSchemaParameters} generateParameters - object comprising all input parameters
+ * @param templateType - template type of the current page
  * @returns the right definition name for the table in the schema
  */
-function alignSchemaWithTemplateType(appSchema, generateParameters) {
+function alignSchemaWithTemplateType(appSchema, templateType) {
     let tableDefinitionName;
     const tableDefinition = appSchema.properties[ux_specification_types_1.PropertyName.table];
-    if (generateParameters.templateType === ux_specification_types_1.TemplateType.AnalyticalListPageV4) {
+    if (templateType === ux_specification_types_1.TemplateType.AnalyticalListPageV4) {
         tableDefinitionName = ux_specification_types_1.DefinitionName.ALPTableView;
         delete tableDefinition.anyOf;
         tableDefinition.$ref = `${utils_1.DEFINITION_LINK_PREFIX}${ux_specification_types_1.DefinitionName.ALPTableView}`;
@@ -993,7 +1035,7 @@ function alignSchemaWithTemplateType(appSchema, generateParameters) {
         delete appSchema.definitions[ux_specification_types_1.DefinitionName.LRTableView];
         delete appSchema.definitions[ux_specification_types_1.DefinitionName.MultiTableModeV4];
     }
-    else if (generateParameters.templateType === ux_specification_types_1.TemplateType.ListReportObjectPageV4) {
+    else if (templateType === ux_specification_types_1.TemplateType.ListReportObjectPageV4) {
         tableDefinitionName = ux_specification_types_1.DefinitionName.Table;
         delete tableDefinition.anyOf;
         tableDefinition.$ref = `${utils_1.DEFINITION_LINK_PREFIX}${ux_specification_types_1.DefinitionName.Table}`;
@@ -1006,14 +1048,15 @@ function alignSchemaWithTemplateType(appSchema, generateParameters) {
 /**
  * Common function for enhancing LineItems, FieldGroups and Custom Section definitions of app schema by custom action definitions.
  *
- * @param appSchema - app-specific JSON schema
- * @param v4Page - actual page in the manifest
- * @param logger - logger for error messages
- * @param customActionDefinitionName - definition name of custom action
- * @param sectionDefinitionName - identifier of the current object page section in schema
- * @param sectionIdInManifest - identifier of the current object page section in manifest
+ * @param appSchema The application schema where the custom action definition will be added.
+ * @param v4Page The V4 page configuration object that contains metadata and settings for the page.
+ * @param logger A logging instance for logging warnings or errors during the processing.
+ * @param customActionDefinitionName The name of the custom action definition to be added. Defaults to `DefinitionName.CustomTableAction`.
+ * @param sectionDefinitionName The name of the section definition within the schema to which the action definition will be added.
+ * @param sectionIdInManifest Optional: The section ID in the manifest, used to derive the configuration ID.
+ * @param lineItemId Optional: The ID of the line item, if applicable.
  */
-function addCustomActionDefinition(appSchema, v4Page, logger, customActionDefinitionName = ux_specification_types_1.DefinitionName.CustomTableAction, sectionDefinitionName = '', sectionIdInManifest = '') {
+function addCustomActionDefinition(appSchema, v4Page, logger, customActionDefinitionName = ux_specification_types_1.DefinitionName.CustomTableAction, sectionDefinitionName = '', sectionIdInManifest = '', lineItemId) {
     const definition = appSchema.definitions[sectionDefinitionName];
     if (!definition) {
         return;
@@ -1045,7 +1088,16 @@ function addCustomActionDefinition(appSchema, v4Page, logger, customActionDefini
         actions = v4Page.options?.settings?.controlConfiguration?.[configId]?.['actions'];
     }
     if (actions) {
-        sortedActionsArray = addExtensionToArray(actions, sortedActionsArray, customActionDefinitionName, 'press', logger);
+        // Add custom actions and custom action menus to the actions array
+        const parameters = {
+            extensions: actions,
+            appSchema,
+            customActionDefinitionName,
+            initialActionDetailsList: sortedActionsArray,
+            logger,
+            lineItemId
+        };
+        sortedActionsArray = addActionsToArray(parameters);
     }
     // Adjust propertyIndex
     if (sortedActionsArray) {
@@ -1081,7 +1133,15 @@ function addHeaderFooterCustomActionDefinition(appSchema, v4Page, logger, custom
         actions = v4Page.options?.settings?.content?.footer?.['actions'];
     }
     if (actions) {
-        sortedActionsArray = addExtensionToArray(actions, sortedActionsArray, customActionDefinitionName, 'press', logger);
+        // Add custom actions and custom action menus to the actions array
+        const parameters = {
+            extensions: actions,
+            appSchema,
+            customActionDefinitionName,
+            initialActionDetailsList: sortedActionsArray,
+            logger
+        };
+        sortedActionsArray = addActionsToArray(parameters);
     }
     // Adjust propertyIndex
     const sortedActionsAsObject = {};
@@ -1093,6 +1153,196 @@ function addHeaderFooterCustomActionDefinition(appSchema, v4Page, logger, custom
     }
     appSchema.definitions[sectionId].properties = sortedActionsAsObject;
 }
+/**
+ * Adds actions and custom action menus to an array of initial actions using specified parameters.
+ *
+ * @param params - An object containing the parameters for adding actions to the array:
+ *   - actions: The original actions to be processed.
+ *   - initialActionsArray: The array to which actions should be added.
+ *   - customActionDefinitionName: The name of the custom action definition.
+ *   - appSchema: The application schema used for processing.
+ *   - logger: An object used for logging information during processing.
+ * @returns An array of action details after processing and adding extensions.
+ */
+function addActionsToArray(params) {
+    const { extensions, initialActionDetailsList, customActionDefinitionName, logger } = params;
+    // Add custom actions
+    let actionDetailsList = addExtensionToArray(extensions, initialActionDetailsList, customActionDefinitionName, [ux_specification_types_1.TemplatePropertyName.Press, ux_specification_types_1.TemplatePropertyName.Menu], logger);
+    const processActionMenusParams = {
+        ...params,
+        initialActionDetailsList: actionDetailsList
+    };
+    actionDetailsList = processActionMenus(processActionMenusParams);
+    return actionDetailsList;
+}
+/**
+ * Processes action menus by identifying menu-type actions within the provided extensions and updating the list of action details accordingly.
+ *
+ * @param {ActionProcessingParameters} params - An object containing required parameters for processing action menus. It includes:
+ *   - extensions: A map of extension data where the keys are extension IDs and the values are extension definitions.
+ *   - initialActionDetailsList: A list of action details, each represented as a tuple with the action ID and action definition.
+ * @returns {Array} An updated list of action details after processing any menu-type actions.
+ */
+function processActionMenus(params) {
+    const { extensions, initialActionDetailsList } = params;
+    let actionDetailsList = [...initialActionDetailsList];
+    // Currently, all actions were initialized as custom actions. We need to check if the action is a menu and if so,
+    // we need to process it differently.
+    for (const extensionId in extensions) {
+        const extension = extensions[extensionId];
+        const actionDetails = actionDetailsList.find(([actionId]) => actionId === extensionId);
+        if (Object.keys(extension).includes(ux_specification_types_1.PropertyName.menu) && actionDetails) {
+            const [, actionDefinition] = actionDetails;
+            actionDetailsList = processActionMenu(params, extension, actionDefinition, actionDetailsList, extensionId);
+        }
+    }
+    return actionDetailsList;
+}
+/**
+ * Retrieves a reference to a menu entry definition based on the provided parameters.
+ *
+ * @param {string} $ref - The reference string used to identify the menu entry definition.
+ * @param {string} actionMenuDefinitionName - The name of the action menu definition.
+ * @param {Definition} appSchema - The application schema containing the definitions.
+ * @returns {string} The constructed link or reference for the specified menu entry definition.
+ */
+function getMenuEntryDefinitionLink($ref, actionMenuDefinitionName, appSchema) {
+    const definitionName = (0, utils_1.getDefinitionKey)($ref);
+    const { baseDefinitionName, definitionQualifier } = parseDefinitionName(definitionName);
+    // incorrect definition name - probably a reference to an intent based navigation action
+    if (baseDefinitionName.includes(exports.FIELD_SEPARATOR)) {
+        return $ref;
+    }
+    const menuEntryDefinitionQualifier = definitionQualifier
+        ? `${actionMenuDefinitionName}${exports.FIELD_SEPARATOR}${definitionQualifier}`
+        : actionMenuDefinitionName;
+    const menuEntryDefinitionRef = (0, common_1.getFacetDefinitionKey)(baseDefinitionName, menuEntryDefinitionQualifier);
+    const menuEntryDefinitionLink = (0, common_1.getFacetDefinitionLink)(baseDefinitionName, menuEntryDefinitionQualifier);
+    const menuEntryDefinition = appSchema.definitions[menuEntryDefinitionRef];
+    if (!menuEntryDefinition) {
+        const originalDefinition = appSchema.definitions[definitionName];
+        const menuEntryDefinition = (0, common_1.parseSchemaDefinition)(baseDefinitionName, menuEntryDefinitionQualifier, appSchema);
+        for (const originalDefinitionKey of Object.keys(originalDefinition)) {
+            if (menuEntryDefinition[originalDefinitionKey] === undefined) {
+                menuEntryDefinition[originalDefinitionKey] = originalDefinition[originalDefinitionKey];
+            }
+        }
+        // some properties doesn't make sense for menu entries
+        delete menuEntryDefinition.properties[ux_specification_types_1.PropertyName.position];
+        delete menuEntryDefinition.properties[ux_specification_types_1.PropertyName.overflowGroup];
+        delete menuEntryDefinition.properties[ux_specification_types_1.PropertyName.priority];
+    }
+    return menuEntryDefinitionLink;
+}
+/**
+ * Determines the appropriate action menu definition name based on a custom action definition name.
+ *
+ * @param {string} customActionDefinitionName - The custom action definition name to be parsed and matched.
+ * @returns {ActionMenuDefinitionName} The corresponding action menu definition name, or a default value if not found.
+ */
+function determineActionMenuDefinitionName(customActionDefinitionName) {
+    const { baseDefinitionName } = parseDefinitionName(customActionDefinitionName);
+    return actionMenuDefinitionNameMap.get(baseDefinitionName) ?? LR_ACTION_MENU_DEFINITION;
+}
+/**
+ * Parses a given definition name into its base name and optional qualifier.
+ *
+ * @param definitionName The definition name to parse. This should be a string in the format "BaseName" or "BaseName<Qualifier>".
+ * @returns An object containing the base definition name and, if applicable, its qualifier.
+ * If there is no qualifier, it will return undefined for the qualifier field.
+ */
+function parseDefinitionName(definitionName = '') {
+    const match = /^([^<]*)(?:<(.*)>)?$/.exec(definitionName);
+    if (!match) {
+        return { baseDefinitionName: definitionName };
+    }
+    const [, baseDefinitionName, definitionQualifier] = match;
+    return {
+        baseDefinitionName: baseDefinitionName,
+        definitionQualifier: definitionQualifier ?? undefined
+    };
+}
+/**
+ * Updates the custom menu's default action to include a list of valid options based on the provided menu schema.
+ *
+ * @param {Definition} customMenuDefinition - The definition object for the custom menu, where the default action will be updated.
+ * @param {Record<string, SchemaDefinition>} [menu={}] - A mapping of menu items to their schema definitions, used to generate valid options for the default action.
+ */
+function setCustomMenuDefaultAction(customMenuDefinition, menu = {}) {
+    if (customMenuDefinition.properties[ux_specification_types_1.PropertyName.defaultAction]) {
+        const menuOneOfValues = Object.keys(menu).map((value) => ({
+            const: value,
+            description: menu[value].description
+        }));
+        customMenuDefinition.properties[ux_specification_types_1.PropertyName.defaultAction][ux_specification_types_1.PropertyName.oneOf] = menuOneOfValues;
+    }
+}
+/**
+ * Retrieves the description of a menu entry from its schema definition.
+ *
+ * @param menuEntryDefinition The schema definition of the menu entry, including its reference information.
+ * @param appSchema The complete application schema containing definitions for the menu entries.
+ * @returns The description of the menu entry if found, or an empty string if no description is available.
+ */
+function getMenuEntryDescription(menuEntryDefinition, appSchema) {
+    const definitionKey = (0, utils_1.getDefinitionKey)(menuEntryDefinition.$ref);
+    const definition = appSchema.definitions[definitionKey];
+    return menuEntryDefinition?.description ?? definition?.description ?? '';
+}
+/**
+ * Processes an action menu for a custom extension, updating the schema definition and action details list accordingly.
+ *
+ * @param {ActionProcessingParameters} params The parameters required for action menu processing, including `actionMenu`, `actionMenuActions`, `appSchema`, and `lineItemId`.
+ * @param {CustomExtension} extension The custom extension that contains the action menu configuration.
+ * @param {SchemaDefinition} actionDefinition The schema definition object to be populated with details of the custom action menu.
+ * @param {ActionDetails[]} initialDetailsList The initial list of action details to be processed and modified.
+ * @param {string} extensionId The unique identifier for the extension being processed.
+ * @returns {ActionDetails[] | undefined} Returns the updated list of action details if processing occurs; otherwise, returns `undefined` if the extension is not a custom action menu.
+ */
+function processActionMenu(params, extension, actionDefinition, initialDetailsList, extensionId) {
+    // if the extension isn't a custom action menu, don't do anything
+    if (!(ux_specification_types_1.TemplatePropertyName.Menu in extension)) {
+        return undefined;
+    }
+    const { customActionDefinitionName, appSchema, lineItemId } = params;
+    const detailsList = [...initialDetailsList];
+    const { actionMenuDefinitionName, actionMenuActionsDefinitionName } = determineActionMenuDefinitionName(customActionDefinitionName);
+    // Prepare submenu entries to be processed
+    const menu = extension[ux_specification_types_1.TemplatePropertyName.Menu] ?? [];
+    const properties = {};
+    // For forms and tables, the id should contain both the section and action names
+    const extendedExtensionId = lineItemId ? `${extensionId}${exports.FIELD_SEPARATOR}${lineItemId}` : extensionId;
+    // Create the specific action menu definition in the schema based on the generic action menu definition
+    const customMenuDefinition = (0, common_1.parseSchemaDefinition)(actionMenuDefinitionName, extendedExtensionId, appSchema);
+    actionDefinition.$ref = (0, common_1.getFacetDefinitionLink)(actionMenuDefinitionName, extendedExtensionId);
+    actionDefinition[ux_specification_types_1.SchemaTag.actionType] = ux_specification_types_1.ActionType.CustomMenu;
+    const customMenuActionsDefinition = (0, common_1.parseSchemaDefinition)(actionMenuActionsDefinitionName, extendedExtensionId, appSchema);
+    const customMenuActionsDefinitionLink = (0, common_1.getFacetDefinitionLink)(actionMenuActionsDefinitionName, extendedExtensionId);
+    // for manifest based menu actions, we need to store the menu entries from the manifest
+    actionDefinition[ux_specification_types_1.PropertyName.menu] = menu;
+    // Add the menu items to the action menu definition
+    menu.forEach((menuEntry, propertyIndex) => {
+        const sortedExtensionIndex = detailsList.findIndex(([entry]) => entry === menuEntry);
+        // If the list of actions contains the menu entry, add the menu entry to the properties of the custom action menu
+        // and remove the extension reference from the list of actions
+        if (sortedExtensionIndex !== -1) {
+            const menuEntryDefinition = detailsList[sortedExtensionIndex][1];
+            menuEntryDefinition.propertyIndex = propertyIndex;
+            menuEntryDefinition.isViewNode = true;
+            menuEntryDefinition.$ref = getMenuEntryDefinitionLink(menuEntryDefinition.$ref, actionMenuDefinitionName, appSchema);
+            menuEntryDefinition.description = getMenuEntryDescription(menuEntryDefinition, appSchema);
+            properties[menuEntry] = menuEntryDefinition;
+            detailsList.splice(sortedExtensionIndex, 1);
+        }
+    });
+    customMenuDefinition.description = actionDefinition.description;
+    // Update the properties of the custom action menu definition with the menu items
+    const actions = customMenuDefinition.properties[ux_specification_types_1.PropertyName.actions];
+    setCustomMenuDefaultAction(customMenuDefinition, properties);
+    customMenuActionsDefinition.properties = properties;
+    actions.$ref = customMenuActionsDefinitionLink;
+    return detailsList;
+}
 /**
  * Method returns page from manifest by passed page key.
  *
@@ -1154,7 +1404,7 @@ function getPageCustomExtensionFile(files, page, manifest, xmlType, extensionNam
         let baseName = fileParts.pop();
         baseName = `${baseName}.${xmlType}.${fileExtension}`;
         const extPath = (0, path_1.join)(...fileParts, baseName);
-        const file = files.find((file) => file.dataSourceUri.endsWith(extPath));
+        const file = (files ?? []).find((file) => file.dataSourceUri.endsWith(extPath));
         if (file) {
             const settings = page.options?.settings;
             return {
@@ -1213,7 +1463,7 @@ function addCustomSectionDefinition(appSchema, definition, v4Page, customSection
         const section = v4Page.options?.settings?.content?.body?.sections?.[facetKey];
         if (section && 'subSections' in section) {
             // add extension to subsection of section
-            sortedSectionsArray = addExtensionToArray(section.subSections, sortedSectionsArray, customSectionRef, 'template', logger, isMergedSections);
+            sortedSectionsArray = addExtensionToArray(section.subSections, sortedSectionsArray, customSectionRef, ux_specification_types_1.TemplatePropertyName.Template, logger, isMergedSections);
         }
     }
     else if (customSectionRef.includes(ux_specification_types_1.DefinitionName.ObjectPageCustomHeaderSectionFragment)) {
@@ -1221,7 +1471,7 @@ function addCustomSectionDefinition(appSchema, definition, v4Page, customSection
         const header = v4Page.options?.settings?.content?.header;
         if (header && 'facets' in header) {
             // add extension to header section
-            sortedSectionsArray = addExtensionToArray(header.facets, sortedSectionsArray, customSectionRef, 'template', logger, isMergedSections);
+            sortedSectionsArray = addExtensionToArray(header.facets, sortedSectionsArray, customSectionRef, ux_specification_types_1.TemplatePropertyName.Template, logger, isMergedSections);
         }
     }
     else {
@@ -1229,7 +1479,7 @@ function addCustomSectionDefinition(appSchema, definition, v4Page, customSection
         const sections = v4Page.options?.settings?.content?.body?.sections;
         if (sections) {
             // add extension to sections section
-            sortedSectionsArray = addExtensionToArray(sections, sortedSectionsArray, customSectionRef, 'template', logger, isMergedSections);
+            sortedSectionsArray = addExtensionToArray(sections, sortedSectionsArray, customSectionRef, ux_specification_types_1.TemplatePropertyName.Template, logger, isMergedSections);
         }
     }
     // Adjust propertyIndex
@@ -1266,7 +1516,7 @@ function addCustomFilterFieldDefinition(appSchema, definition, v4Page) {
     const selectionFieldsEntry = v4Page.options?.settings?.controlConfiguration?.[`@${"com.sap.vocabularies.UI.v1.SelectionFields" /* UIAnnotationTerms.SelectionFields */}`];
     if (typeof selectionFieldsEntry === 'object' && 'filterFields' in selectionFieldsEntry) {
         // add extension to subsection of section
-        sortedFilterFieldsArray = addExtensionToArray(selectionFieldsEntry.filterFields, sortedFilterFieldsArray, ux_specification_types_1.DefinitionName.CustomFilterField, 'template');
+        sortedFilterFieldsArray = addExtensionToArray(selectionFieldsEntry.filterFields, sortedFilterFieldsArray, ux_specification_types_1.DefinitionName.CustomFilterField, ux_specification_types_1.TemplatePropertyName.Template);
     }
     // Adjust propertyIndex
     for (let index = 0; index < sortedFilterFieldsArray.length; index++) {
@@ -1285,7 +1535,6 @@ function addCustomFilterFieldDefinition(appSchema, definition, v4Page) {
  * @param {object} importActionParams - Parameters required for importing action settings, including schema, factory, and action specifications.
  * @param {string} key - The key used to identify the specific configuration or schema definition.
  * @param {boolean} [keepEmptyAction] - Determines whether to keep empty actions in the configuration object.
- * @returns {void} This method does not return any value.
  */
 function importActionToConfigurationObject(importActionParams, key, keepEmptyAction = false) {
     const { appSchema, factory, actionsInConfig, actionKey, manifest, routingId, manifestSectionId, targetAnnotation } = importActionParams;
@@ -1308,7 +1557,6 @@ function importActionToConfigurationObject(importActionParams, key, keepEmptyAct
  *
  * @param {ImportActionSettingsOfReferenceParams} importActionParams - The parameters required for importing action settings, including property definitions.
  * @param {Definition} definitionOfReference - The reference definition object used to resolve the action.
- * @returns {void} This function does not return a value.
  */
 function importSingleActionSettingsOfReference(importActionParams, definitionOfReference) {
     const { actionPropertyDefinition } = importActionParams;
@@ -1318,20 +1566,26 @@ function importSingleActionSettingsOfReference(importActionParams, definitionOfR
 /**
  * Imports and processes the settings for a group of actions based on a reference definition.
  *
- * @param {ImportActionSettingsOfReferenceParams} importActionParams - The parameters used for importing and configuring the action settings.
- * @param {Definition} definitionOfReference - The reference definition from which the action group settings are imported.
+ * @param {ImportActionSettingsOfReferenceParams} importActionParams - Parameters containing details required to import group action settings, such as action property definitions, application schema, action configurations, and action keys.
+ * @param {Definition} definitionOfReference - The definition object that serves as the reference for importing group action settings.
  * @param {string} definitionKey - Optional, the reference definition key from which the action group settings are imported.
- * @returns {void} This function does not return a value; it modifies the configurations directly.
  */
 function importGroupActionSettingsOfReference(importActionParams, definitionOfReference, definitionKey) {
     const { actionPropertyDefinition, appSchema, actionsInConfig, actionKey } = importActionParams;
+    let resolvedDefinitionOfReference = definitionOfReference;
+    let resolvedDefinitionKey = (0, utils_1.getDefinitionKey)(resolvedDefinitionOfReference.$ref ?? actionPropertyDefinition.$ref);
+    /* Some action groups (e.g. form group actions) have wrapper definition in the schema, in such cases we need to use the referenced definition. */
+    const hasActionGroupWrapper = (0, utils_1.getDefinitionKey)(definitionOfReference.$ref) === `ObjectPageFormActionGroup<${definitionKey}>`;
+    if (hasActionGroupWrapper) {
+        resolvedDefinitionKey = (0, utils_1.getDefinitionKey)(definitionOfReference.$ref);
+        resolvedDefinitionOfReference = appSchema.definitions[resolvedDefinitionKey];
+    }
     // create an instance of the action group in the configuration object
-    const key = definitionKey ?? (0, utils_1.getDefinitionKey)(definitionOfReference.$ref ?? actionPropertyDefinition.$ref);
-    importActionToConfigurationObject(importActionParams, key, true);
+    importActionToConfigurationObject(importActionParams, resolvedDefinitionKey, true);
     // newly created action group instance is available in the actionsInConfig object
     const actionGroup = actionsInConfig[actionKey];
     // fill the action group with the action settings of the group action
-    const { properties } = definitionOfReference;
+    const { properties } = resolvedDefinitionOfReference;
     for (const propertyKey in properties) {
         const actionInGroupProperty = properties[propertyKey];
         if (actionInGroupProperty['$ref']) {
@@ -1342,41 +1596,73 @@ function importGroupActionSettingsOfReference(importActionParams, definitionOfRe
                 ...importActionParams,
                 actionsInConfig: actionGroup,
                 actionKey: propertyKey
-                // targetAnnotation: undefined
             };
             importActionToConfigurationObject(importGroupedActionParams, key);
         }
     }
     (0, common_1.removeEmptyStructure)(actionsInConfig, actionKey);
 }
+/**
+ * Imports and updates the action menu settings in a configuration object based on a given reference definition and related action parameters.
+ *
+ * @param {ImportActionSettingsOfReferenceParams} importActionParams - An object containing details such as the action property definition, application schema, actions configuration, and action key. These parameters are used for resolving and importing the settings.
+ * @param {Definition} definitionOfReference - The reference definition object which includes properties and other settings required to define action menus and their related configurations.
+ */
+function importManifestBasedActionMenuSettingsOfReference(importActionParams, definitionOfReference) {
+    const { actionPropertyDefinition, appSchema, actionsInConfig, actionKey } = importActionParams;
+    // create an instance of the menu action in the configuration object
+    const key = (0, utils_1.getDefinitionKey)(definitionOfReference.$ref ?? actionPropertyDefinition.$ref);
+    importActionToConfigurationObject(importActionParams, key, true);
+    // newly created menu action instance is available in the actionsInConfig object
+    const menuAction = actionsInConfig[actionKey];
+    menuAction[ux_specification_types_1.PropertyName.menu] = actionPropertyDefinition[ux_specification_types_1.PropertyName.menu];
+    menuAction[ux_specification_types_1.PropertyName.actions] = {};
+    menuAction[ux_specification_types_1.PropertyName.text] = definitionOfReference.description;
+    const actionsDefinitionKey = (0, utils_1.getDefinitionKey)(definitionOfReference?.properties?.[ux_specification_types_1.PropertyName.actions]?.$ref);
+    const actionsDefinition = appSchema.definitions[actionsDefinitionKey];
+    // fill the action menu with the action settings of the menu action
+    const actions = actionsDefinition?.properties ?? {};
+    for (const action in actions) {
+        const actionInMenuActionProperty = actions[action];
+        const actionInMenuActionPropertyKey = (0, utils_1.getDefinitionKey)(actionInMenuActionProperty['$ref']);
+        const actionInMenuActionDefinition = appSchema.definitions[actionInMenuActionPropertyKey];
+        const key = (0, utils_1.getDefinitionKey)(actionInMenuActionDefinition?.$ref ?? actionInMenuActionProperty['$ref']);
+        const importMenuActionParams = {
+            ...importActionParams,
+            actionsInConfig: menuAction[ux_specification_types_1.PropertyName.actions],
+            actionKey: action
+        };
+        importActionToConfigurationObject(importMenuActionParams, key);
+    }
+    (0, common_1.removeEmptyStructure)(actionsInConfig, actionKey);
+}
+/**
+ * Determines the strategy type for action settings based on the provided data type and action type.
+ *
+ * @param {string} [dataType=''] - The data type associated with the action settings. Defaults to an empty string.
+ * @param {string} [actionType=''] - The action type within the context of the action settings. Defaults to an empty string.
+ * @returns {DataFieldStrategyTypes} The corresponding strategy type for the given data type and action type.
+ */
+function determineActionStrategyType(dataType = '', actionType = '') {
+    const key = `${dataType}${actionType}`;
+    return strategyTypeMap.get(key) || "com.sap.vocabularies.UI.v1.DataFieldForAction" /* UIAnnotationTypes.DataFieldForAction */;
+}
 /**
  * Imports the action settings of a specified reference based on the given parameters.
  *
  * @param {object} importActionParams - The parameters required for importing action settings.
  * @param {object} importActionParams.actionPropertyDefinition - The action property definition containing the $ref to the reference.
  * @param {object} importActionParams.appSchema - The application schema containing definitions and other related metadata.
- * @returns {void} This function does not return a value.
  */
 function importActionSettingsOfReference(importActionParams) {
     const { actionPropertyDefinition, appSchema } = importActionParams;
     const definitionKey = (0, utils_1.getDefinitionKey)(actionPropertyDefinition.$ref);
     const definitionOfReference = appSchema.definitions[definitionKey];
-    const actionType = definitionOfReference['dataType'];
-    if (actionType === exports.DATA_FIELD_FOR_ACTION_GROUP) {
-        /* Some action groups (e.g. form group actions) have wrapper definition in the schema, in such cases we need to use the referenced definition. */
-        const definitionOfReferenceKey = (0, utils_1.getDefinitionKey)(definitionOfReference.$ref);
-        if (definitionOfReferenceKey === `ObjectPageFormActionGroup<${definitionKey}>`) {
-            const definitionKey = (0, utils_1.getDefinitionKey)(definitionOfReference.$ref);
-            const actualAtionGroupDefinition = appSchema.definitions[definitionKey];
-            importGroupActionSettingsOfReference(importActionParams, actualAtionGroupDefinition, definitionKey);
-        }
-        else {
-            importGroupActionSettingsOfReference(importActionParams, definitionOfReference);
-        }
-    }
-    else {
-        importSingleActionSettingsOfReference(importActionParams, definitionOfReference);
-    }
+    const dataType = definitionOfReference?.['dataType'];
+    const actionType = actionPropertyDefinition?.[ACTION_TYPE];
+    const strategyType = determineActionStrategyType(dataType, actionType);
+    const strategy = DataFieldStrategy_1.dataFieldStrategyContext.getStrategy(strategyType);
+    strategy.importActionSettingsOfReference(importActionParams, definitionOfReference, definitionKey);
 }
 /**
  * Enhances the application schema with custom field definitions for Object Page sections.
@@ -1398,7 +1684,7 @@ function addCustomFieldDefinition(appSchema, v4Page, fieldGroupInManifest, logge
     const configId = fieldGroupInManifest.replace(/::/g, '#');
     const fields = v4Page.options?.settings?.controlConfiguration?.[configId]?.['fields'];
     if (fields) {
-        sortedFieldsArray = addExtensionToArray(fields, sortedFieldsArray, customFieldDefinitionName, 'template', logger);
+        sortedFieldsArray = addExtensionToArray(fields, sortedFieldsArray, customFieldDefinitionName, ux_specification_types_1.TemplatePropertyName.Template, logger);
     }
     // Adjust propertyIndex
     if (sortedFieldsArray) {
@@ -1418,55 +1704,8 @@ function addCustomFieldDefinition(appSchema, v4Page, fieldGroupInManifest, logge
  *   If `undefined`, the function attempts to resolve the definition name from the `$ref` property of the provided definition.
  * @param {Definition} definition - The definition object containing property schemas.
  * @param {ManifestPathParams} pathParams - Additional context required to compute manifest paths.
- * @param {ManifestPropertyResolution} [parentProperty] - Information about the parent property used when resolving
- *   nested or inherited manifest paths (e.g. parent property name and resolved rule path).
  */
-function addManifestPathsToProperties(appSchema, definitionName, definition, pathParams, parentProperty) {
-    // If `definitionName` is undefined, attempt to resolve it from the definition's `$ref`
-    if (definitionName === undefined && definition.$ref) {
-        const innerDefinitionKey = (0, utils_1.getDefinitionKey)(definition.$ref);
-        const innerDefinition = appSchema.definitions[innerDefinitionKey];
-        if (innerDefinition && !innerDefinition.isViewNode) {
-            definition = innerDefinition;
-            // Resolve root definition name in case if reference has syntax like `definitionName<annotation>`
-            definitionName = innerDefinitionKey?.split('<')[0];
-        }
-    }
-    const classControl = v4controls[definitionName] ?? pages[definitionName];
-    if (!classControl) {
-        return;
-    }
-    if (!definition.properties && definition.$ref) {
-        const innerDefinition = (0, utils_1.getDefinitionKey)(definition.$ref);
-        definition = appSchema.definitions?.[innerDefinition] ?? definition;
-    }
-    for (const property in definition.properties ?? {}) {
-        const rule = (0, common_1.getReflectMetadata)(classControl.prototype, property);
-        const propertySchema = definition.properties[property];
-        const propertyPath = {
-            name: property
-        };
-        if (rule?.manifest?.path) {
-            let rulePath = rule?.manifest?.path([pathParams.pageName], pathParams.manifest, ...pathParams.pathsParts);
-            if (rulePath === parentProperty?.rulePath) {
-                rulePath = `${rulePath}/${parentProperty.name}`;
-            }
-            const manifestPath = `${rulePath}/${property}`;
-            propertySchema.manifestPath = (0, utils_1.convertSyncRulePathToJsonPath)(manifestPath, pathParams.targetAnnotation, pathParams.targetAnnotationEncoded);
-            propertyPath.rulePath = rulePath;
-        }
-        // Recursively apply manifest paths to properties referenced via `$ref`
-        if (propertySchema.$ref) {
-            addManifestPathsToProperties(appSchema, undefined, propertySchema, pathParams, propertyPath);
-        }
-        // Recursively apply manifest paths to properties inside `anyOf` variants
-        if (propertySchema.anyOf) {
-            for (const schemaVariant of propertySchema.anyOf) {
-                if (typeof schemaVariant === 'object') {
-                    addManifestPathsToProperties(appSchema, undefined, schemaVariant, pathParams, propertyPath);
-                }
-            }
-        }
-    }
+function addManifestPathsToProperties(appSchema, definitionName, definition, pathParams) {
+    (0, utils_1.addManifestPathsToProperties)([v4controls, pages], appSchema, definitionName, definition, pathParams);
 }
 //# sourceMappingURL=utils.js.map