@sap/ux-specification 1.136.17 → 1.136.19

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

@@ -38,6 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QUALIFIER_SEPARATOR = exports.FIELD_SEPARATOR = exports.DATA_FIELD_FOR_ACTION_GROUP = void 0;
 exports.addExtensionToArray = addExtensionToArray;
+exports.getColumnsEnum = getColumnsEnum;
 exports.addEnumForProperties = addEnumForProperties;
 exports.addCustomColumnDefinition = addCustomColumnDefinition;
 exports.addActionRecordToSchema = addActionRecordToSchema;
@@ -67,6 +68,7 @@ exports.importManifestBasedActionMenuSettingsOfReference = importManifestBasedAc
 exports.importActionSettingsOfReference = importActionSettingsOfReference;
 exports.addCustomFieldDefinition = addCustomFieldDefinition;
 exports.addManifestPathsToProperties = addManifestPathsToProperties;
+exports.getInsertableForEntitySet = getInsertableForEntitySet;
 exports.getPageManifestPath = getPageManifestPath;
 const utils_1 = require("../../common/utils");
 const StableIdHelper_1 = require("./StableIdHelper");
@@ -78,14 +80,20 @@ const path_1 = require("path");
 const DataFieldStrategy_1 = require("../../common/DataFieldStrategy");
 const utils_2 = require("../import/utils");
 const src_1 = require("@sap/ux-specification-types/src");
-const objectPage_1 = require("../generate/objectPage");
 const v4controls = __importStar(require("../export/controls"));
 const pages = __importStar(require("../export/pages"));
 const application_1 = require("../application");
+const propertiesForEdit_1 = require("../generate/utils/propertiesForEdit");
 exports.DATA_FIELD_FOR_ACTION_GROUP = 'DataFieldForActionGroup';
 const UI_ANNOTATION_KEY = 'UI';
 exports.FIELD_SEPARATOR = '::';
 exports.QUALIFIER_SEPARATOR = '#';
+/**
+ * List of annotation-based action prefixes that should be included in the schema
+ * even if they lack custom action properties (press, menu), so they can be validated
+ * and removed during export if they don't match the config.
+ */
+const ANNOTATION_BASED_ACTION_PREFIXES = [`${ux_specification_types_1.DataFieldActionType.DataFieldForIntentBasedNavigation}${exports.FIELD_SEPARATOR}`];
 const ACTION_TYPE = 'actionType';
 const strategyTypeMap = new Map([
     ['', "com.sap.vocabularies.UI.v1.DataFieldForAction" /* UIAnnotationTypes.DataFieldForAction */],
@@ -95,19 +103,23 @@ const strategyTypeMap = new Map([
 ]);
 const OP_ACTION_MENU_DEFINITION = {
     actionMenuDefinitionName: ux_specification_types_1.DefinitionName.ObjectPageCustomActionMenu,
-    actionMenuActionsDefinitionName: ux_specification_types_1.DefinitionName.ObjectPageCustomActionMenuActions
+    actionMenuActionsDefinitionName: ux_specification_types_1.DefinitionName.ObjectPageCustomActionMenuActions,
+    actionName: ux_specification_types_1.DefinitionName.ObjectPageToolBarAction
 };
 const OP_HEADER_ACTION_MENU_DEFINITION = {
     actionMenuDefinitionName: ux_specification_types_1.DefinitionName.ObjectPageHeaderCustomActionMenu,
-    actionMenuActionsDefinitionName: ux_specification_types_1.DefinitionName.ObjectPageHeaderCustomActionMenuActions
+    actionMenuActionsDefinitionName: ux_specification_types_1.DefinitionName.ObjectPageHeaderCustomActionMenuActions,
+    actionName: ux_specification_types_1.DefinitionName.ObjectPageHeaderAction
 };
 const LR_ACTION_MENU_DEFINITION = {
     actionMenuDefinitionName: ux_specification_types_1.DefinitionName.CustomActionMenu,
-    actionMenuActionsDefinitionName: ux_specification_types_1.DefinitionName.CustomActionMenuActions
+    actionMenuActionsDefinitionName: ux_specification_types_1.DefinitionName.CustomActionMenuActions,
+    actionName: ux_specification_types_1.DefinitionName.ToolBarAction
 };
 const LR_ACTION_VIEW_MENU_DEFINITION = {
     actionMenuDefinitionName: ux_specification_types_1.DefinitionName.ViewCustomActionMenu,
-    actionMenuActionsDefinitionName: ux_specification_types_1.DefinitionName.ViewCustomActionMenuActions
+    actionMenuActionsDefinitionName: ux_specification_types_1.DefinitionName.ViewCustomActionMenuActions,
+    actionName: ux_specification_types_1.DefinitionName.ViewToolBarAction
 };
 const actionMenuDefinitionNameMap = new Map([
     [ux_specification_types_1.DefinitionName.CustomTableActionOP, OP_ACTION_MENU_DEFINITION],
@@ -234,7 +246,7 @@ function getExtensionDetails(extension, extensionDefinitionName, extId, actionTy
  * @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.
+ * @param {boolean} [forceAdd] - 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;
@@ -406,6 +418,110 @@ function handleInvalidExtension(logger, extensionId, sortedExtensionsArray, newE
     sortedExtensionsArray.push([extensionId, newExtensionReference]);
     delete localExtensions[extensionId];
 }
+/**
+ * Checks if an extension ID represents an annotation-based action.
+ * Annotation-based actions should be included in the schema even if they lack custom action
+ * properties (press, menu), so they can be validated and removed during export if they don't match the config.
+ *
+ * @param {string} extensionId - The extension ID to check.
+ * @returns {boolean} True if the extension is an annotation-based action, false otherwise.
+ */
+function isAnnotationBasedAction(extensionId) {
+    return ANNOTATION_BASED_ACTION_PREFIXES.some((prefix) => extensionId.startsWith(prefix));
+}
+/**
+ * Handles orphaned annotation-based actions that exist in manifest but not in annotations.
+ * These actions must be added to the schema to enable cleanup during export.
+ *
+ * @param {string} extensionId - The extension ID.
+ * @param {any} extension - The extension object.
+ * @param {string} extensionDefinitionName - The definition name associated with the extensions.
+ * @param {Definition} [appSchema] - Optional application schema for creating specific definitions.
+ * @param {ActionDetails[]} sortedExtensionsArray - The array to add the action to.
+ */
+function handleOrphanedAnnotationAction(extensionId, extension, extensionDefinitionName, appSchema, sortedExtensionsArray) {
+    // This is an annotation-based action from manifest that doesn't exist in annotations.
+    // IMPORTANT: We must add these orphaned actions to the schema to enable cleanup.
+    //
+    // When an action is renamed (e.g., IBN action's semantic object changes), the old
+    // action key remains in the manifest but disappears from the config (annotations).
+    // By adding it to the schema, the export process can detect this mismatch and remove
+    // the orphaned entry from the manifest. If we don't add it to the schema, it will be
+    // ignored and remain as garbage in the manifest forever.
+    //
+    // Process:
+    // 1. Add orphaned action to schema with Standard action type
+    // 2. During export: compare schema with config
+    // 3. Action in schema but NOT in config → remove from manifest
+    // 4. Action in schema AND in config → keep in manifest
+    if (appSchema) {
+        // Create specific definition name and schema like "ToolBarActionGroup<DataFieldForActionGroup::AnnoActionMenu>"
+        const { actionName } = determineActionDefinitionNames(extensionDefinitionName);
+        const preparedRef = (0, common_1.prepareRef)(extensionId);
+        const specificDefinitionName = (0, common_1.getFacetDefinitionKey)(actionName, preparedRef);
+        // Create the schema definition for this action
+        (0, common_1.parseSchemaDefinition)(actionName, preparedRef, appSchema);
+        const correctedExtensionReference = getExtensionDetails(extension, specificDefinitionName, extensionId, ux_specification_types_1.ActionType.Standard);
+        sortedExtensionsArray.push([extensionId, correctedExtensionReference]);
+    }
+    else {
+        // Fallback if no appSchema provided
+        const correctedExtensionReference = getExtensionDetails(extension, extensionDefinitionName, extensionId, ux_specification_types_1.ActionType.Standard);
+        sortedExtensionsArray.push([extensionId, correctedExtensionReference]);
+    }
+}
+/**
+ * Recursively checks if an action exists in annotation entries, including nested actions within action groups.
+ *
+ * @param {string} extensionId - The unique identifier for the extension to search for.
+ * @param {ActionDetails[]} annotationEntries - Array of actions to search through.
+ * @param {Definition | undefined} appSchema - Optional application schema to look up action group definitions.
+ * @returns {boolean} True if the action exists at any level (top-level or nested in groups).
+ */
+function actionExistsInAnnotations(extensionId, annotationEntries, appSchema) {
+    for (const [id, actionDef] of annotationEntries) {
+        // Check top-level match
+        if (id === extensionId) {
+            return true;
+        }
+        // Check if this is an action group with nested actions
+        const actionDefinition = actionDef;
+        if (appSchema && actionDefinition.$ref) {
+            const defKey = actionDefinition.$ref.replace('#/definitions/', '');
+            const definition = appSchema.definitions?.[defKey];
+            // If it's an action group, check its nested actions (properties)
+            if (definition && definition.properties) {
+                const nestedActions = Object.entries(definition.properties).map(([nestedId, nestedDef]) => [nestedId, nestedDef]);
+                // Recursively search nested actions
+                if (actionExistsInAnnotations(extensionId, nestedActions, appSchema)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Processes annotation-based actions with unsupported extension types.
+ * Either skips duplicates or handles orphaned actions.
+ *
+ * @param {string} extensionId - The extension ID.
+ * @param {any} extension - The extension object.
+ * @param {string} extensionDefinitionName - The definition name.
+ * @param {Definition} [appSchema] - Optional application schema.
+ * @param {ActionDetails[]} annotationEntries - Array of annotation entries.
+ * @param {ActionDetails[]} sortedExtensionsArray - The sorted extensions array.
+ */
+function processAnnotationBasedAction(extensionId, extension, extensionDefinitionName, appSchema, annotationEntries, sortedExtensionsArray) {
+    // Check if this annotation-based action exists in annotationEntries (including nested in action groups)
+    const existsInAnnotations = actionExistsInAnnotations(extensionId, annotationEntries, appSchema);
+    if (existsInAnnotations) {
+        // Action already exists from annotations - skip it to avoid duplicates
+        return;
+    }
+    // Handle orphaned annotation-based action
+    handleOrphanedAnnotationAction(extensionId, extension, extensionDefinitionName, appSchema, sortedExtensionsArray);
+}
 /**
  * Adds extension entries to a sorted array of extensions based on specific rules,
  * including using anchors, callbacks, and custom templates.
@@ -413,13 +529,14 @@ function handleInvalidExtension(logger, extensionId, sortedExtensionsArray, newE
  * @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] -
+ * @param {TemplatePropertyName | TemplatePropertyName[]} [templatePropertyName] -
  * 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.
+ * @param {Definition} [appSchema] - Optional application schema for creating specific definitions for annotation-based actions.
  * @returns {ActionDetails[]} The updated sorted extensions array, including newly added and valid extensions.
  */
-function addExtensionToArray(extensions, sortedExtensionsArray, extensionDefinitionName, templatePropertyName = ux_specification_types_1.TemplatePropertyName.Template, logger, ignoreAnnotationAnchors = false) {
+function addExtensionToArray(extensions, sortedExtensionsArray, extensionDefinitionName, templatePropertyName = ux_specification_types_1.TemplatePropertyName.Template, logger, ignoreAnnotationAnchors = false, appSchema) {
     templatePropertyName = Array.isArray(templatePropertyName) ? templatePropertyName : [templatePropertyName];
     const annotationEntries = [...sortedExtensionsArray];
     const localExtensions = { ...extensions };
@@ -439,9 +556,17 @@ function addExtensionToArray(extensions, sortedExtensionsArray, extensionDefinit
         }
         const hasUnsupportedExtensionType = templatePropertyName.every((propertyName) => !(propertyName in extension));
         if (hasUnsupportedExtensionType) {
-            // Skip regular entries(columns, actions, etc.)
-            delete localExtensions[extensionId];
-            continue;
+            const isAnnotationBased = isAnnotationBasedAction(extensionId);
+            if (isAnnotationBased) {
+                processAnnotationBasedAction(extensionId, extension, extensionDefinitionName, appSchema, annotationEntries, sortedExtensionsArray);
+                delete localExtensions[extensionId];
+                continue;
+            }
+            else {
+                // Skip regular entries (columns, actions, etc.) that don't have required properties
+                delete localExtensions[extensionId];
+                continue;
+            }
         }
         const anchor = getExtensionAnchor(extension, annotationEntries);
         if (anchor) {
@@ -464,16 +589,39 @@ function addExtensionToArray(extensions, sortedExtensionsArray, extensionDefinit
     return sortedExtensionsArray;
 }
 /**
- * Returns column names for enum.
+ * Extracts the column name from the keys metadata of a column definition.
+ * Returns the value from 'Target' or 'Value' key, with UI namespace stripped.
  *
- * @param lineItems - current lineItems definition, with all records.
- * @returns Column names.
+ * @param keys - Array of schema definition keys from the column definition.
+ * @returns The column name with proper separators, or undefined if not found.
+ */
+function getColumnNameFromKeys(keys) {
+    if (!keys?.length) {
+        return undefined;
+    }
+    const keyEntry = keys.find((k) => k.name === ux_specification_types_1.SchemaKeyName.target || k.name === ux_specification_types_1.SchemaKeyName.value);
+    if (!keyEntry?.value) {
+        return undefined;
+    }
+    // Strip UI. namespace prefix (e.g., "UI.FieldGroup#qual" -> "FieldGroup#qual")
+    return keyEntry.value.replace(/\bUI\./g, '');
+}
+/**
+ * Returns column names for enum, extracted from the keys metadata of each column.
+ * Only columns with 'Target' or 'Value' keys are included (excludes actions).
+ *
+ * @param lineItems - Current lineItems definition, with all records.
+ * @returns Column names with proper separators (/ for navigation, # for qualifiers).
  */
 function getColumnsEnum(lineItems) {
+    if (typeof lineItems === 'boolean') {
+        return [];
+    }
     const columnEnum = [];
-    for (const key of Object.keys(lineItems)) {
-        if (key.indexOf(exports.FIELD_SEPARATOR) > -1) {
-            columnEnum.push(key.substring(key.indexOf(exports.FIELD_SEPARATOR) + 2));
+    for (const definition of Object.values(lineItems)) {
+        const columnName = getColumnNameFromKeys(definition?.[ux_specification_types_1.SchemaTag.keys]);
+        if (columnName) {
+            columnEnum.push(columnName);
         }
     }
     return columnEnum;
@@ -492,7 +640,7 @@ function removeDataFieldPrefix(key) {
  * Extracts and processes the columns defined in the given lineItems or Definition object,
  * returning an array of CreationFieldOneOfOption.
  *
- * @param {Definition} [columns={}] - An object containing column definitions where keys represent field identifiers
+ * @param {Definition} [columns] - An object containing column definitions where keys represent field identifiers
  *                                     and values are field metadata.
  * @returns {CreationFieldOneOfOption[]} An array of field options, each containing field-specific metadata.
  */
@@ -653,14 +801,28 @@ function addActionRecordToSchema(lineItemDefinitionParams, createRef = true) {
     //no footer bar -> toolbar action
     const actionDefinitionName = determineActionDefinitionName(data, lineItemRecord);
     const description = (0, common_1.getDataFieldDescription)(lineItemRecord, data.entityType);
-    const prefix = lineItemRecord.$Type.split(`${ux_specification_types_1.UIVOCABULARY}.`)[1];
+    // 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);
+    // 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 propertyKey = (0, StableIdHelper_1.replaceSpecialChars)(actionId);
-    const actionDefinition = (actionsDefinition.properties[`${prefix}::${propertyKey}`] = {
+    // 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
+    // should be treated as different actions, not duplicates.
+    const stableIdWithoutPrefix = stableId.split('::').slice(1).join('::');
+    // Create action definition with full stable ID as property key.
+    // This allows manifest-based menus to correctly reference actions by their complete identity.
+    const actionDefinition = (actionsDefinition.properties[stableId] = {
         description
     });
     if (createRef) {
-        actionDefinition.$ref = (0, common_1.getUniqueFacetDefinitionLink)(actionDefinitionName, (0, common_1.prepareRef)(propertyKey), data.appSchema, lineItemPath);
+        actionDefinition.$ref = (0, common_1.getUniqueFacetDefinitionLink)(actionDefinitionName, (0, common_1.prepareRef)(stableIdWithoutPrefix), data.appSchema, lineItemPath);
     }
     else {
         actionDefinition.properties = {};
@@ -893,15 +1055,34 @@ function addEnumForActionAnchor(appSchema, definitionId, positionName = ux_speci
  * @param {EntityType} [entityType] - Optional entity type for additional context when retrieving column definitions.
  */
 function addEnumForEnableMassEdit(appSchema, tableDefinitionName, columnsDefinitionName, entityType) {
+    if (!entityType) {
+        return;
+    }
     const FIELD_PROPERTIES = ['visibleFields', 'ignoredFields'];
-    const columnsDefinitions = getNonNavigationColumnDefinitions(appSchema, columnsDefinitionName, entityType);
-    const columnEnums = getColumnsEnum(columnsDefinitions);
-    const enableMassEditDefinition = appSchema.definitions[tableDefinitionName].properties['enableMassEdit'];
-    const enableMassEditFields = enableMassEditDefinition.anyOf.find((definition) => definition.type === 'object');
+    const columnsDefinitions = appSchema.definitions?.[columnsDefinitionName];
+    // Ignore check for hidden properties
+    const filterOptions = {
+        hidden: null
+    };
+    const fieldGroupsList = (0, propertiesForEdit_1.buildFieldGroupsList)(columnsDefinitions, entityType, filterOptions, 'single');
+    const singleFieldList = (0, propertiesForEdit_1.buildSingleFieldList)(columnsDefinitions, entityType, filterOptions);
+    const enableMassEditDefinition = (appSchema.definitions?.[tableDefinitionName]).properties?.['enableMassEdit'];
+    const enableMassEditFields = enableMassEditDefinition.anyOf?.find((definition) => typeof definition === 'object' && definition && definition.type === 'object');
     for (const propertyKey in enableMassEditFields.properties) {
         if (FIELD_PROPERTIES.includes(propertyKey)) {
             const property = enableMassEditFields.properties[propertyKey];
-            property.items['enum'] = columnEnums;
+            property.items = {
+                type: 'string',
+                // Indicate that items are tree structure
+                uiType: 'tree',
+                // Selection restricted within single group
+                restrictGroups: true,
+                // Only value from single group is allowed
+                exclusiveGroups: ['FieldGroup'],
+                // Allow annotation FieldGroup creation
+                creation: 'FieldGroup',
+                oneOf: [...fieldGroupsList, ...singleFieldList]
+            };
             property.uniqueItems = true;
         }
     }
@@ -942,14 +1123,25 @@ function getNonNavigationColumnDefinitions(appSchema, lineItemId, entityType) {
  * @returns {string} The name of the newly created specific schema definition for the creation mode.
  */
 function initializeCreationModeSchema(appSchema, lineItemId, entityType, definitionName) {
+    const definitions = appSchema.definitions;
     const columnDefinitions = getNonNavigationColumnDefinitions(appSchema, lineItemId, entityType);
-    const columnOneOfEnums = getCreationFieldOptions(columnDefinitions);
-    const fieldGroups = getFieldGroupsFromEntityType(entityType);
+    const fieldGroupsList = entityType
+        ? (0, propertiesForEdit_1.buildFieldGroupsList)(columnDefinitions, entityType, undefined, 'single', false)
+        : [];
+    const singleFieldList = entityType ? (0, propertiesForEdit_1.buildSingleFieldList)(columnDefinitions, entityType) : [];
     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];
+    const specificCreationModeDefinition = (definitions[specificCreationModeDefinitionName] = structuredClone(definitions[definitionName]));
+    const creationFieldsDefinition = specificCreationModeDefinition.properties?.[ux_specification_types_1.PropertyName.creationFields];
     const creationFieldsDefinitionItems = creationFieldsDefinition.items;
-    creationFieldsDefinitionItems['oneOf'] = [...columnOneOfEnums, ...fieldGroups];
+    creationFieldsDefinitionItems['oneOf'] = [...fieldGroupsList, ...singleFieldList];
+    // Indicate that items are tree structure
+    creationFieldsDefinitionItems['uiType'] = 'tree';
+    // Allow annotation FieldGroup creation
+    creationFieldsDefinitionItems['creation'] = 'FieldGroup';
+    // Selection restricted within single group
+    creationFieldsDefinitionItems['restrictGroups'] = true;
+    // Only value from single group is allowed
+    creationFieldsDefinitionItems['exclusiveGroups'] = ['FieldGroup'];
     // Entries of one of are translatable using 'service' i18n bundle
     creationFieldsDefinitionItems.i18nBundle = 'service';
     creationFieldsDefinition.uniqueItems = true;
@@ -966,20 +1158,12 @@ function initializeCreationModeSchema(appSchema, lineItemId, entityType, definit
  */
 function addOneOfForCreationFields(appSchema, entityType, definitionName, lineItemId) {
     const creationModeDefinitionName = initializeCreationModeSchema(appSchema, lineItemId, entityType, definitionName);
-    // replace the generic creationMode definition with the specific one for all table types
-    objectPage_1.OBJECT_PAGE_TABLE_DEFINITION_TYPES.forEach((type) => {
-        const creationModeAnyOf = appSchema.definitions[`${type}<${lineItemId}>`]?.properties?.creationMode?.anyOf;
-        if (creationModeAnyOf) {
-            const updatedCreationModeAnyOf = creationModeAnyOf.map((definition) => {
-                const { $ref } = definition;
-                // replace generic creation mode definition with specific one
-                // I don't check that $ref contains the definition name, the replacement should not work for other definitions
-                const updatedRef = $ref.replace(definitionName, creationModeDefinitionName);
-                return { ...definition, $ref: updatedRef };
-            });
-            appSchema.definitions[`${type}<${lineItemId}>`].properties.creationMode.anyOf = updatedCreationModeAnyOf;
-        }
-    });
+    // Replace the generic creationMode definition reference with the facet-specific one
+    const tableDefinition = appSchema.definitions[`${ux_specification_types_1.DefinitionName.ObjectPageTable}<${lineItemId}>`];
+    const creationModeProperty = tableDefinition?.properties?.creationMode;
+    if (creationModeProperty?.$ref) {
+        creationModeProperty.$ref = creationModeProperty.$ref.replace(definitionName, creationModeDefinitionName);
+    }
 }
 /**
  * Find the relevant V4 page under the routing targets of manifest,json.
@@ -1156,7 +1340,7 @@ function addHeaderFooterCustomActionDefinition(appSchema, v4Page, logger, custom
 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);
+    let actionDetailsList = addExtensionToArray(extensions, initialActionDetailsList, customActionDefinitionName, [ux_specification_types_1.TemplatePropertyName.Press, ux_specification_types_1.TemplatePropertyName.Menu], logger, false, params.appSchema);
     const processActionMenusParams = {
         ...params,
         initialActionDetailsList: actionDetailsList
@@ -1216,19 +1400,31 @@ function getMenuEntryDefinitionLink($ref, actionMenuDefinitionName, appSchema) {
                 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.priority];
+        // some properties doesn't make sense for menu entries - hide them instead of deleting
+        // NOTE: This is a necessary trade-off. When moving IBN actions in and out of menus,
+        // we keep these properties visible in the manifest but hidden in the UI.
+        // Unfortunately, this is required - otherwise, when renaming actions, we end up with
+        // orphaned entries in the manifest.
+        if (menuEntryDefinition.properties[ux_specification_types_1.PropertyName.position]) {
+            menuEntryDefinition.properties[ux_specification_types_1.PropertyName.position][ux_specification_types_1.SchemaTag.hidden] = true;
+        }
+        if (menuEntryDefinition.properties[ux_specification_types_1.PropertyName.overflowGroup]) {
+            menuEntryDefinition.properties[ux_specification_types_1.PropertyName.overflowGroup][ux_specification_types_1.SchemaTag.hidden] = true;
+        }
+        if (menuEntryDefinition.properties[ux_specification_types_1.PropertyName.priority]) {
+            menuEntryDefinition.properties[ux_specification_types_1.PropertyName.priority][ux_specification_types_1.SchemaTag.hidden] = true;
+        }
     }
     return menuEntryDefinitionLink;
 }
 /**
- * Determines the appropriate action menu definition name based on a custom action definition name.
+ * Determines the appropriate action definition names based on a custom action definition name.
+ * Returns menu definition names and the action name for menu entries.
  *
  * @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.
+ * @returns {ActionMenuDefinitionName} The corresponding action definition names, or a default value if not found.
  */
-function determineActionMenuDefinitionName(customActionDefinitionName) {
+function determineActionDefinitionNames(customActionDefinitionName) {
     const { baseDefinitionName } = parseDefinitionName(customActionDefinitionName);
     return actionMenuDefinitionNameMap.get(baseDefinitionName) ?? LR_ACTION_MENU_DEFINITION;
 }
@@ -1254,7 +1450,7 @@ function parseDefinitionName(definitionName = '') {
  * 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.
+ * @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]) {
@@ -1294,7 +1490,7 @@ function processActionMenu(params, extension, actionDefinition, initialDetailsLi
     }
     const { customActionDefinitionName, appSchema, lineItemId } = params;
     const detailsList = [...initialDetailsList];
-    const { actionMenuDefinitionName, actionMenuActionsDefinitionName } = determineActionMenuDefinitionName(customActionDefinitionName);
+    const { actionMenuDefinitionName, actionMenuActionsDefinitionName } = determineActionDefinitionNames(customActionDefinitionName);
     // Prepare submenu entries to be processed
     const menu = extension[ux_specification_types_1.TemplatePropertyName.Menu] ?? [];
     const properties = {};
@@ -1627,8 +1823,8 @@ function importManifestBasedActionMenuSettingsOfReference(importActionParams, de
 /**
  * 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.
+ * @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 = '') {
@@ -1712,6 +1908,63 @@ function addCustomFieldDefinition(appSchema, v4Page, fieldGroupInManifest, logge
 function addManifestPathsToProperties(appSchema, definitionName, definition, pathParams, handleRelative = false) {
     (0, utils_1.addManifestPathsToProperties)([v4controls, pages], appSchema, definitionName, definition, pathParams, undefined, handleRelative);
 }
+/**
+ * Determines whether an entity set or navigation target is insertable based on its annotations.
+ *
+ * When navigationPath is provided:
+ * 1. Checks NavigationRestrictions.RestrictedProperties on the source EntitySet
+ * 2. Resolves the target EntitySet via navigationPropertyBinding
+ * 3. Checks InsertRestrictions on the target EntitySet
+ * 4. Both must allow insertion for the function to return true
+ *
+ * When navigationPath is not provided:
+ * 1. Checks InsertRestrictions on the given EntitySet
+ *
+ * For Path-based (dynamic) Insertable values, always returns true (shows creationMode).
+ *
+ * @param entitySet - The source entity set (where navigation starts from, or the entity set being checked)
+ * @param navigationPath - Optional navigation property path (e.g., "_Booking", "to_Items")
+ * @returns A boolean indicating whether insertion is allowed. Returns true if the insertability is Path-based (dynamic) or undefined.
+ */
+function getInsertableForEntitySet(entitySet, navigationPath) {
+    // Check NavigationRestrictions if navigation path provided
+    // Default: allow if not specified (Path-based values are also treated as true)
+    let navigationInsertable = true;
+    if (navigationPath) {
+        const navRestrictions = entitySet?.annotations?.Capabilities?.NavigationRestrictions;
+        if (navRestrictions?.RestrictedProperties) {
+            const restriction = navRestrictions.RestrictedProperties.find((prop) => prop.NavigationProperty?.value === navigationPath);
+            if (restriction?.InsertRestrictions?.Insertable !== undefined) {
+                const navInsertable = restriction.InsertRestrictions.Insertable;
+                if (typeof navInsertable === 'boolean') {
+                    navigationInsertable = navInsertable;
+                }
+            }
+        }
+        // Resolve target EntitySet via navigationPropertyBinding
+        const targetEntitySet = entitySet?.navigationPropertyBinding?.[navigationPath];
+        if (targetEntitySet && '_type' in targetEntitySet && targetEntitySet._type === 'EntitySet') {
+            // Default: allow if not specified (Path-based values are also treated as true)
+            let targetEntitySetInsertable = true;
+            const targetRestriction = targetEntitySet.annotations?.Capabilities?.InsertRestrictions?.Insertable;
+            if (typeof targetRestriction === 'boolean') {
+                targetEntitySetInsertable = targetRestriction;
+            }
+            // Both Navigation and Target EntitySet must allow insertion
+            return navigationInsertable && targetEntitySetInsertable;
+        }
+        // If no targetEntitySet found, only check navigation restrictions
+        return navigationInsertable;
+    }
+    // No navigation path: check EntitySet-level InsertRestrictions
+    // Default: allow if not specified (Path-based values are also treated as true)
+    let entitySetInsertable = true;
+    const entitySetRestriction = entitySet?.annotations?.Capabilities?.InsertRestrictions?.Insertable;
+    if (typeof entitySetRestriction === 'boolean') {
+        entitySetInsertable = entitySetRestriction;
+    }
+    return entitySetInsertable;
+}
 /**
  * Returns the manifest path for a given page based on the provided path parameters.
  *