@sap-ux/ui5-test-writer 0.7.89 → 0.7.90

package/dist/fiori-elements-opa-writer.d.ts

@@ -18,6 +18,7 @@ export declare function readManifest(fs: Editor, basePath: string): Manifest;
  * @param opaConfig.scriptName - the name of the OPA journey file. If not specified, 'FirstJourney' will be used
  * @param opaConfig.htmlTarget - the name of the html that will be used in OPA journey file. If not specified, 'index.html' will be used
  * @param opaConfig.appID - the appID. If not specified, will be read from the manifest in sap.app/id
+ * @param metadata - optional metadata for the OPA test generation
  * @param fs - an optional reference to a mem-fs editor
  * @param log - optional logger instance
  * @returns Reference to a mem-fs-editor
@@ -26,7 +27,7 @@ export declare function generateOPAFiles(basePath: string, opaConfig: {
     scriptName?: string;
     appID?: string;
     htmlTarget?: string;
-}, fs?: Editor, log?: Logger): Promise<Editor>;
+}, metadata?: string, fs?: Editor, log?: Logger): Promise<Editor>;
 /**
  * Generate a page object file for a Fiori elements for OData V4 application.
  * Note: this doesn't modify other existing files in the webapp/test folder.

package/dist/fiori-elements-opa-writer.js

@@ -214,11 +214,12 @@ function writePageObject(pageConfig, rootTemplateDirPath, testOutDirPath, fs) {
  * @param opaConfig.scriptName - the name of the OPA journey file. If not specified, 'FirstJourney' will be used
  * @param opaConfig.htmlTarget - the name of the html that will be used in OPA journey file. If not specified, 'index.html' will be used
  * @param opaConfig.appID - the appID. If not specified, will be read from the manifest in sap.app/id
+ * @param metadata - optional metadata for the OPA test generation
  * @param fs - an optional reference to a mem-fs editor
  * @param log - optional logger instance
  * @returns Reference to a mem-fs-editor
  */
-async function generateOPAFiles(basePath, opaConfig, fs, log) {
+async function generateOPAFiles(basePath, opaConfig, metadata, fs, log) {
     const editor = fs ?? (0, mem_fs_editor_1.create)((0, mem_fs_1.create)());
     const manifest = readManifest(editor, basePath);
     const { applicationType, hideFilterBar } = getAppTypeAndHideFilterBarFromManifest(manifest);
@@ -232,10 +233,6 @@ async function generateOPAFiles(basePath, opaConfig, fs, log) {
     { appId: config.appID }, undefined, {
         globOptions: { dot: true }
     });
-    // Integration (OPA) test files - version-specific
-    editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration', 'opaTests.*.*'), (0, node_path_1.join)(testOutDirPath, 'integration'), config, undefined, {
-        globOptions: { dot: true }
-    });
     // Pages files (one for each page in the app)
     config.pages.forEach((page) => {
         writePageObject(page, rootV4TemplateDirPath, testOutDirPath, editor);
@@ -244,18 +241,50 @@ async function generateOPAFiles(basePath, opaConfig, fs, log) {
     const startPages = config.pages.filter((page) => page.isStartup).map((page) => page.targetKey);
     const LROP = findLROP(config.pages, manifest);
     // Access ux-specification to get feature data for OPA test generation
-    const { filterBarItems, tableColumns } = await (0, modelUtils_1.getFeatureData)(basePath, editor, log);
+    const { listReport, objectPages, fpm } = await (0, modelUtils_1.getAppFeatures)(basePath, editor, log, metadata);
     const journeyParams = {
         startPages,
         startLR: LROP.pageLR?.targetKey,
         navigatedOP: LROP.pageOP?.targetKey,
-        hideFilterBar: config.hideFilterBar,
-        filterBarItems: filterBarItems,
-        tableColumns: tableColumns
+        hideFilterBar: config.hideFilterBar
     };
+    const generatedJourneyPages = [];
     editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration/FirstJourney.js'), (0, node_path_1.join)(testOutDirPath, `integration/${config.opaJourneyFileName}.js`), journeyParams, undefined, {
         globOptions: { dot: true }
     });
+    if (listReport) {
+        editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration/ListReportJourney.js'), (0, node_path_1.join)(testOutDirPath, `integration/${listReport.name}Journey.js`), {
+            ...journeyParams,
+            ...listReport
+        }, undefined, {
+            globOptions: { dot: true }
+        });
+        generatedJourneyPages.push(listReport.name);
+    }
+    if (objectPages && objectPages.length > 0) {
+        objectPages.forEach((objectPage) => {
+            editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration/ObjectPageJourney.js'), (0, node_path_1.join)(testOutDirPath, `integration/${objectPage.name}Journey.js`), {
+                ...journeyParams,
+                ...objectPage
+            }, undefined, {
+                globOptions: { dot: true }
+            });
+            generatedJourneyPages.push(objectPage.name);
+        });
+    }
+    if (fpm) {
+        editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration/FPMJourney.js'), (0, node_path_1.join)(testOutDirPath, `integration/${fpm.name}Journey.js`), {
+            ...journeyParams,
+            ...fpm
+        }, undefined, {
+            globOptions: { dot: true }
+        });
+        generatedJourneyPages.push(fpm.name);
+    }
+    // Integration (OPA) test files - version-specific
+    editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration', 'opaTests.*.*'), (0, node_path_1.join)(testOutDirPath, 'integration'), { ...config, generatedJourneyPages }, undefined, {
+        globOptions: { dot: true }
+    });
     // Journey Runner
     editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration', 'pages', 'JourneyRunner.js'), (0, node_path_1.join)(testOutDirPath, 'integration', 'pages', 'JourneyRunner.js'), config, undefined, {
         globOptions: { dot: true }

package/dist/types.d.ts

@@ -62,8 +62,109 @@ export interface FFOPAConfig {
     ui5Version?: string;
     ui5Theme?: string;
 }
-export type FeatureData = {
+export type ObjectPageNavigationParents = {
+    parentLRName?: string;
+    parentOPName?: string;
+    parentOPTableSection?: string;
+};
+export type ObjectPageFeatures = {
+    name?: string;
+    navigationParents?: ObjectPageNavigationParents;
+    headerTitle?: string;
+    headerDescription?: string;
+    headerSections?: HeaderSectionFeatureData[];
+};
+export type ListReportFeatures = {
+    name?: string;
+    createButton?: {
+        enabled?: boolean | string;
+        visible?: boolean;
+        dynamicPath?: string;
+    };
+    deleteButton?: {
+        enabled?: boolean | string;
+        visible: boolean;
+        dynamicPath?: string;
+    };
+    filterBarItems?: string[];
+    tableColumns?: Record<string, Record<string, string | number | boolean>>;
+    toolBarActions?: ActionButtonState[];
+};
+export interface ActionButtonState {
+    label: string;
+    action: string;
+    visible: boolean;
+    /**
+     * Indicates whether the action button is enabled.
+     * - true: Button is enabled and can be invoked
+     * - false: Button is disabled
+     * - 'dynamic': The state is controlled by a dynamic path annotation (e.g., Core.OperationAvailable)
+     */
+    enabled: boolean | 'dynamic';
+    /**
+     * If the enabled state is dynamic, this contains the path to the control property.
+     * For example: "_it/__OperationControl/deductDiscount"
+     */
+    dynamicPath?: string;
+    /**
+     * The invocation grouping type if specified (e.g., "Isolated", "ChangeSet").
+     */
+    invocationGrouping?: string;
+}
+export type FPMFeatures = {
+    name?: string;
     filterBarItems?: string[];
     tableColumns?: Record<string, Record<string, string | number | boolean>>;
 };
+export type AppFeatures = {
+    listReport?: ListReportFeatures;
+    objectPages?: ObjectPageFeatures[];
+    fpm?: FPMFeatures;
+};
+export type HeaderSectionFeatureData = {
+    facetId?: string;
+    title?: string;
+    custom?: boolean;
+    collection?: boolean;
+    microChart?: boolean;
+    form?: boolean;
+    stashed?: boolean | string;
+    fields?: {
+        fieldGroupQualifier?: string;
+        field?: string;
+    }[];
+};
+export interface ButtonState {
+    visible: boolean;
+    /**
+     * - true: Button is enabled and can be clicked
+     * - false: Button is disabled
+     * - 'dynamic': The state is controlled by a dynamic path annotation (e.g., Path="__EntityControl/Deletable")
+     */
+    enabled: boolean | 'dynamic';
+    dynamicPath?: string;
+}
+export interface ButtonVisibilityResult {
+    /**
+     * State of the Create button based on Capabilities.InsertRestrictions annotation.
+     */
+    create: ButtonState;
+    /**
+     * State of the Delete button based on Capabilities.DeleteRestrictions annotation.
+     */
+    delete: ButtonState;
+}
+/**
+ * Result interface for action button checks.
+ */
+export interface ActionButtonsResult {
+    /**
+     * List of action buttons found in the UI.LineItem annotation.
+     */
+    actions: ActionButtonState[];
+    /**
+     * The entity type name that these actions belong to.
+     */
+    entityType: string;
+}
 //# sourceMappingURL=types.d.ts.map

package/dist/utils/listReportUtils.d.ts

@@ -0,0 +1,94 @@
+import type { Logger } from '@sap-ux/logger';
+import type { TreeAggregations, TreeModel } from '@sap/ux-specification/dist/types/src/parser';
+import type { ActionButtonsResult, ActionButtonState, ButtonState, ButtonVisibilityResult, ListReportFeatures } from '../types';
+import type { PageWithModelV4 } from '@sap/ux-specification/dist/types/src/parser/application';
+/**
+ * Builds a button state object from button visibility result.
+ *
+ * @param buttonState - The button state from visibility check
+ * @returns Button state object with visible, enabled, and optional dynamicPath properties
+ */
+export declare function buildButtonState(buttonState?: ButtonState): {
+    visible: boolean;
+    enabled?: boolean | 'dynamic';
+    dynamicPath?: string;
+};
+/**
+ * Safely checks button visibility with error handling.
+ *
+ * @param metadata - The OData metadata XML content
+ * @param entitySetName - The name of the entity set
+ * @param log - Optional logger instance
+ * @returns Button visibility result or undefined if error occurs
+ */
+export declare function safeCheckButtonVisibility(metadata: string, entitySetName: string, log?: Logger): ButtonVisibilityResult | undefined;
+/**
+ * Safely checks action button states with error handling.
+ *
+ * @param metadata - The OData metadata XML content
+ * @param entitySetName - The name of the entity set
+ * @param actionNames - List of action names to check
+ * @param log - Optional logger instance
+ * @returns Array of action button states or empty array if error occurs
+ */
+export declare function safeCheckActionButtonStates(metadata: string, entitySetName: string, actionNames: string[], log?: Logger): ActionButtonState[];
+/**
+ * Gets List Report features from the page model using ux-specification.
+ *
+ * @param listReportPage - the List Report page containing the tree model with feature definitions
+ * @param log - optional logger instance
+ * @param metadata - optional metadata for the OPA test generation
+ * @returns feature data extracted from the List Report page model
+ */
+export declare function getListReportFeatures(listReportPage: PageWithModelV4, log?: Logger, metadata?: string): ListReportFeatures;
+/**
+ * Retrieves toolbar action definitions from the given tree model.
+ *
+ * @param pageModel - The tree model containing toolbar definitions.
+ * @returns The toolbar actions aggregation object.
+ */
+export declare function getToolBarActions(pageModel: TreeModel): TreeAggregations;
+/**
+ * Checks the visibility and enabled state of create and delete buttons for a given entity set
+ * by analyzing OData Capabilities annotations in the metadata.
+ *
+ * @param metadataXml The OData metadata XML content as a string
+ * @param entitySetName The name of the entity set to check
+ * @returns ButtonVisibilityResult containing the state of create and delete buttons
+ * @throws {Error} If metadata cannot be parsed or entity set is not found
+ */
+export declare function checkButtonVisibility(metadataXml: string, entitySetName: string): ButtonVisibilityResult;
+/**
+ * Retrieves filter field names from the page model using ux-specification.
+ *
+ * @param pageModel - the tree model containing filter bar definitions
+ * @param log - optional logger instance
+ * @returns - an array of filter field names
+ */
+export declare function getFilterFieldNames(pageModel: TreeModel, log?: Logger): string[];
+/**
+ * Checks the state of action buttons defined in UI.LineItem annotations for a given entity set.
+ *
+ * @param metadataXml The OData metadata XML content as a string
+ * @param entitySetName The name of the entity set to check
+ * @param actionNames Optional list of action names to filter (e.g., ['Check', 'deductDiscount']). If not provided, returns all actions.
+ * @returns ActionButtonsResult containing the list of action buttons and their states
+ * @throws {Error} If metadata cannot be parsed or entity set is not found
+ */
+export declare function checkActionButtonStates(metadataXml: string, entitySetName: string, actionNames?: string[]): ActionButtonsResult;
+/**
+ * Retrieves toolbar action names from the page model using ux-specification.
+ *
+ * @param pageModel - the tree model containing toolbar definitions
+ * @param log - optional logger instance
+ * @returns - an array of toolbar action names
+ */
+export declare function getToolBarActionNames(pageModel: TreeModel, log?: Logger): string[];
+/**
+ * Retrieves toolbar action items from the given toolbar actions aggregation.
+ *
+ * @param toolBarActionsAgg - The toolbar actions aggregation containing action definitions.
+ * @returns An array of toolbar action descriptions.
+ */
+export declare function getToolBarActionItems(toolBarActionsAgg: TreeAggregations): string[];
+//# sourceMappingURL=listReportUtils.d.ts.map

package/dist/utils/listReportUtils.js

@@ -0,0 +1,389 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildButtonState = buildButtonState;
+exports.safeCheckButtonVisibility = safeCheckButtonVisibility;
+exports.safeCheckActionButtonStates = safeCheckActionButtonStates;
+exports.getListReportFeatures = getListReportFeatures;
+exports.getToolBarActions = getToolBarActions;
+exports.checkButtonVisibility = checkButtonVisibility;
+exports.getFilterFieldNames = getFilterFieldNames;
+exports.checkActionButtonStates = checkActionButtonStates;
+exports.getToolBarActionNames = getToolBarActionNames;
+exports.getToolBarActionItems = getToolBarActionItems;
+const modelUtils_1 = require("./modelUtils");
+const edmx_parser_1 = require("@sap-ux/edmx-parser");
+const annotation_converter_1 = require("@sap-ux/annotation-converter");
+/**
+ * Builds a button state object from button visibility result.
+ *
+ * @param buttonState - The button state from visibility check
+ * @returns Button state object with visible, enabled, and optional dynamicPath properties
+ */
+function buildButtonState(buttonState) {
+    return {
+        visible: !!buttonState?.visible,
+        enabled: buttonState?.enabled,
+        dynamicPath: buttonState?.enabled === 'dynamic' ? buttonState.dynamicPath : undefined
+    };
+}
+/**
+ * Safely checks button visibility with error handling.
+ *
+ * @param metadata - The OData metadata XML content
+ * @param entitySetName - The name of the entity set
+ * @param log - Optional logger instance
+ * @returns Button visibility result or undefined if error occurs
+ */
+function safeCheckButtonVisibility(metadata, entitySetName, log) {
+    try {
+        return checkButtonVisibility(metadata, entitySetName);
+    }
+    catch (error) {
+        log?.debug(`Failed to check button visibility: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+    }
+}
+/**
+ * Safely checks action button states with error handling.
+ *
+ * @param metadata - The OData metadata XML content
+ * @param entitySetName - The name of the entity set
+ * @param actionNames - List of action names to check
+ * @param log - Optional logger instance
+ * @returns Array of action button states or empty array if error occurs
+ */
+function safeCheckActionButtonStates(metadata, entitySetName, actionNames, log) {
+    try {
+        return checkActionButtonStates(metadata, entitySetName, actionNames).actions;
+    }
+    catch (error) {
+        log?.debug(`Failed to check action button states: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+}
+/**
+ * Gets List Report features from the page model using ux-specification.
+ *
+ * @param listReportPage - the List Report page containing the tree model with feature definitions
+ * @param log - optional logger instance
+ * @param metadata - optional metadata for the OPA test generation
+ * @returns feature data extracted from the List Report page model
+ */
+function getListReportFeatures(listReportPage, log, metadata) {
+    const buttonVisibility = metadata && listReportPage.entitySet
+        ? safeCheckButtonVisibility(metadata, listReportPage.entitySet, log)
+        : undefined;
+    const toolbarActions = getToolBarActionNames(listReportPage.model, log);
+    return {
+        name: listReportPage.name,
+        createButton: buildButtonState(buttonVisibility?.create),
+        deleteButton: buildButtonState(buttonVisibility?.delete),
+        filterBarItems: getFilterFieldNames(listReportPage.model, log),
+        tableColumns: (0, modelUtils_1.getTableColumnData)(listReportPage.model, log),
+        toolBarActions: metadata && listReportPage.entitySet
+            ? safeCheckActionButtonStates(metadata, listReportPage.entitySet, toolbarActions, log)
+            : []
+    };
+}
+/**
+ * Retrieves toolbar action definitions from the given tree model.
+ *
+ * @param pageModel - The tree model containing toolbar definitions.
+ * @returns The toolbar actions aggregation object.
+ */
+function getToolBarActions(pageModel) {
+    const table = (0, modelUtils_1.getAggregations)(pageModel.root)['table'];
+    const tableAggregations = (0, modelUtils_1.getAggregations)(table);
+    const toolBar = tableAggregations['toolBar'];
+    const toolBarAggregations = (0, modelUtils_1.getAggregations)(toolBar);
+    const actions = toolBarAggregations['actions'];
+    const actionAggregations = (0, modelUtils_1.getAggregations)(actions);
+    return actionAggregations;
+}
+/**
+ * Checks the visibility and enabled state of create and delete buttons for a given entity set
+ * by analyzing OData Capabilities annotations in the metadata.
+ *
+ * @param metadataXml The OData metadata XML content as a string
+ * @param entitySetName The name of the entity set to check
+ * @returns ButtonVisibilityResult containing the state of create and delete buttons
+ * @throws {Error} If metadata cannot be parsed or entity set is not found
+ */
+function checkButtonVisibility(metadataXml, entitySetName) {
+    try {
+        const convertedMetadata = (0, annotation_converter_1.convert)((0, edmx_parser_1.parse)(metadataXml));
+        const entitySet = convertedMetadata.entitySets.find((es) => es.name === entitySetName);
+        if (!entitySet) {
+            throw new Error(`Entity set '${entitySetName}' not found in metadata`);
+        }
+        const insertRestrictions = entitySet.annotations?.Capabilities?.InsertRestrictions;
+        const deleteRestrictions = entitySet.annotations?.Capabilities?.DeleteRestrictions;
+        return {
+            create: analyzeRestriction(insertRestrictions, 'Insertable'),
+            delete: analyzeRestriction(deleteRestrictions, 'Deletable')
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to analyze button visibility: ${errorMessage}`);
+    }
+}
+/**
+ * Retrieves filter field names from the page model using ux-specification.
+ *
+ * @param pageModel - the tree model containing filter bar definitions
+ * @param log - optional logger instance
+ * @returns - an array of filter field names
+ */
+function getFilterFieldNames(pageModel, log) {
+    let filterBarItems = [];
+    try {
+        const filterBarAggregations = (0, modelUtils_1.getFilterFields)(pageModel);
+        filterBarItems = (0, modelUtils_1.getSelectionFieldItems)(filterBarAggregations);
+    }
+    catch (error) {
+        log?.debug(error);
+    }
+    if (!filterBarItems?.length) {
+        log?.warn('Unable to extract filter fields from project model using specification. No filter field tests will be generated.');
+    }
+    return filterBarItems;
+}
+/**
+ * Analyzes a capability restriction annotation to determine button state.
+ *
+ * @param restriction The restriction annotation object (InsertRestrictions or DeleteRestrictions)
+ * @param propertyName The property name to check ('Insertable' or 'Deletable')
+ * @returns ButtonState for the button
+ */
+function analyzeRestriction(restriction, propertyName) {
+    const defaultState = { visible: true, enabled: true };
+    if (!restriction) {
+        return defaultState;
+    }
+    const value = restriction[propertyName];
+    if (value === undefined || value === null) {
+        return defaultState;
+    }
+    if (typeof value === 'boolean') {
+        return { visible: value, enabled: value };
+    }
+    if (typeof value === 'object' && value !== null) {
+        const path = value.$Path ?? value.path;
+        if (path) {
+            return { visible: true, enabled: 'dynamic', dynamicPath: path };
+        }
+    }
+    return defaultState;
+}
+/**
+ * Checks the state of action buttons defined in UI.LineItem annotations for a given entity set.
+ *
+ * @param metadataXml The OData metadata XML content as a string
+ * @param entitySetName The name of the entity set to check
+ * @param actionNames Optional list of action names to filter (e.g., ['Check', 'deductDiscount']). If not provided, returns all actions.
+ * @returns ActionButtonsResult containing the list of action buttons and their states
+ * @throws {Error} If metadata cannot be parsed or entity set is not found
+ */
+function checkActionButtonStates(metadataXml, entitySetName, actionNames) {
+    try {
+        const convertedMetadata = (0, annotation_converter_1.convert)((0, edmx_parser_1.parse)(metadataXml));
+        const entitySet = convertedMetadata.entitySets.find((es) => es.name === entitySetName);
+        if (!entitySet) {
+            throw new Error(`Entity set '${entitySetName}' not found in metadata`);
+        }
+        const entityType = entitySet.entityType;
+        if (!entityType) {
+            throw new Error(`Entity type not found for entity set '${entitySetName}'`);
+        }
+        const lineItemAnnotation = entityType.annotations?.UI?.LineItem;
+        if (!lineItemAnnotation || !Array.isArray(lineItemAnnotation)) {
+            return { actions: [], entityType: entityType.name };
+        }
+        const dataFieldForActions = lineItemAnnotation.filter((item) => item.$Type === 'com.sap.vocabularies.UI.v1.DataFieldForAction');
+        const actions = actionNames
+            ? findActionStates(dataFieldForActions, actionNames, convertedMetadata, entityType.name)
+            : extractAllActionStates(dataFieldForActions, convertedMetadata, entityType.name);
+        return { actions, entityType: entityType.name };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to analyze action button states: ${errorMessage}`);
+    }
+}
+/**
+ * Finds action states for a specific list of action names.
+ *
+ * @param dataFieldForActions List of DataFieldForAction items from UI.LineItem
+ * @param actionNames List of action names to find
+ * @param metadata The converted metadata
+ * @param entityTypeName The entity type name
+ * @returns List of action button states for the specified actions
+ */
+function findActionStates(dataFieldForActions, actionNames, metadata, entityTypeName) {
+    const actionStates = [];
+    for (const actionName of actionNames) {
+        const item = dataFieldForActions.find((dfa) => {
+            const actionMethod = extractActionMethodName(dfa.Action || '');
+            return actionMethod === actionName || dfa.Label === actionName;
+        });
+        if (item) {
+            actionStates.push(buildActionButtonState(item, metadata, entityTypeName));
+        }
+    }
+    return actionStates;
+}
+/**
+ * Extracts action states for all DataFieldForAction items.
+ *
+ * @param dataFieldForActions List of DataFieldForAction items from UI.LineItem
+ * @param metadata The converted metadata
+ * @param entityTypeName The entity type name
+ * @returns List of all action button states
+ */
+function extractAllActionStates(dataFieldForActions, metadata, entityTypeName) {
+    return dataFieldForActions.map((item) => buildActionButtonState(item, metadata, entityTypeName));
+}
+/**
+ * Builds an ActionButtonState object from a DataFieldForAction item.
+ *
+ * @param item The DataFieldForAction item
+ * @param metadata The converted metadata
+ * @param entityTypeName The entity type name
+ * @returns ActionButtonState for the action
+ */
+function buildActionButtonState(item, metadata, entityTypeName) {
+    const actionMethod = extractActionMethodName(item.Action || '');
+    const operationAvailable = findOperationAvailableAnnotation(metadata, entityTypeName, actionMethod);
+    const { enabled, dynamicPath } = analyzeOperationAvailability(operationAvailable);
+    return {
+        label: item.Label || '',
+        action: item.Action || '',
+        visible: true,
+        enabled,
+        dynamicPath,
+        invocationGrouping: item.InvocationGrouping ? extractEnumMemberValue(item.InvocationGrouping) : undefined
+    };
+}
+/**
+ * Analyzes Core.OperationAvailable annotation to determine action availability.
+ *
+ * @param operationAvailable The OperationAvailable annotation value
+ * @returns Object containing enabled state and optional dynamic path
+ */
+function analyzeOperationAvailability(operationAvailable) {
+    if (operationAvailable === undefined) {
+        return { enabled: true };
+    }
+    if (typeof operationAvailable === 'boolean') {
+        return { enabled: operationAvailable };
+    }
+    if (typeof operationAvailable === 'object' && operationAvailable !== null) {
+        const path = operationAvailable.$Path ?? operationAvailable.path;
+        if (path) {
+            return { enabled: 'dynamic', dynamicPath: path };
+        }
+    }
+    return { enabled: true };
+}
+/**
+ * Extracts the action method name from a fully qualified action string.
+ *
+ * @param actionName The fully qualified action name
+ * @returns The action method name
+ */
+function extractActionMethodName(actionName) {
+    const match = /\.([^.()]+)\(/.exec(actionName);
+    if (match?.[1]) {
+        return match[1];
+    }
+    const lastDotIndex = actionName.lastIndexOf('.');
+    const parenIndex = actionName.indexOf('(');
+    if (lastDotIndex !== -1 && parenIndex !== -1) {
+        return actionName.substring(lastDotIndex + 1, parenIndex);
+    }
+    return actionName;
+}
+/**
+ * Finds the Core.OperationAvailable annotation for a specific action.
+ *
+ * @param metadata The converted metadata
+ * @param entityTypeName The entity type name
+ * @param actionMethodName The action method name
+ * @returns The OperationAvailable annotation value or undefined if not found
+ */
+function findOperationAvailableAnnotation(metadata, entityTypeName, actionMethodName) {
+    if (metadata.actions) {
+        const action = metadata.actions.find((a) => a.name === actionMethodName || a.fullyQualifiedName?.includes(`.${actionMethodName}(`));
+        if (action?.annotations?.Core?.OperationAvailable !== undefined) {
+            return action.annotations.Core.OperationAvailable;
+        }
+    }
+    if (metadata.entityContainer?.annotations) {
+        const annotations = metadata.entityContainer.annotations;
+        const matchingKey = Object.keys(annotations).find((key) => key.includes(actionMethodName));
+        if (matchingKey && annotations[matchingKey]?.Core?.OperationAvailable !== undefined) {
+            return annotations[matchingKey].Core.OperationAvailable;
+        }
+    }
+    return undefined;
+}
+/**
+ * Extracts the enum member value from an annotation.
+ *
+ * @param enumValue The enum value object
+ * @returns The extracted enum value string
+ */
+function extractEnumMemberValue(enumValue) {
+    if (typeof enumValue === 'string') {
+        return enumValue;
+    }
+    if (enumValue?.$EnumMember) {
+        const parts = enumValue.$EnumMember.split('/');
+        return parts[1] ?? enumValue.$EnumMember;
+    }
+    return undefined;
+}
+/**
+ * Retrieves toolbar action names from the page model using ux-specification.
+ *
+ * @param pageModel - the tree model containing toolbar definitions
+ * @param log - optional logger instance
+ * @returns - an array of toolbar action names
+ */
+function getToolBarActionNames(pageModel, log) {
+    let toolBarActions = [];
+    try {
+        const toolbarActions = getToolBarActions(pageModel);
+        toolBarActions = getToolBarActionItems(toolbarActions);
+    }
+    catch (error) {
+        log?.debug(error);
+    }
+    if (!toolBarActions?.length) {
+        log?.warn('Unable to extract toolbar actions from project model using specification. No toolbar action tests will be generated.');
+    }
+    return toolBarActions;
+}
+/**
+ * Retrieves toolbar action items from the given toolbar actions aggregation.
+ *
+ * @param toolBarActionsAgg - The toolbar actions aggregation containing action definitions.
+ * @returns An array of toolbar action descriptions.
+ */
+function getToolBarActionItems(toolBarActionsAgg) {
+    return extractItemDescriptions(toolBarActionsAgg);
+}
+/**
+ * Extracts item descriptions from tree aggregations.
+ *
+ * @param aggregations - The tree aggregations containing item definitions
+ * @returns An array of item descriptions
+ */
+function extractItemDescriptions(aggregations) {
+    if (aggregations && typeof aggregations === 'object') {
+        return Object.keys(aggregations).map((key) => aggregations[key].description);
+    }
+    return [];
+}
+//# sourceMappingURL=listReportUtils.js.map