@sapui5/sap.suite.ui.generic.template 1.148.0 → 1.148.2

package/src/sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillFieldCollector.js

@@ -0,0 +1,848 @@
+sap.ui.define([
+    "sap/suite/ui/generic/template/genericUtilities/FeLogger",
+    "sap/suite/ui/generic/template/genericUtilities/FeError",
+    "sap/suite/ui/generic/template/genericUtilities/controlHelper"
+], function(FeLogger, FeError, controlHelper) {
+    "use strict";
+
+    var sClassName = "lib.ai.EasyFill.EasyFillFieldCollector";
+    var oLogger = new FeLogger(sClassName).getLogger();
+
+    /**
+     * EasyFillFieldCollector
+     *
+     * Responsible for:
+     * 1. Building the field mapping payload sent to the LLM (entity set properties + collection/table properties).
+     * 2. Determining which LLM-returned fields are updatable vs. non-updatable based on OData metadata annotations.
+     * 3. Building the section tree structures (Condensed and ObjectPage views) that drive the dialog's SmartForm layout.
+     *
+     * This module absorbs the logic previously split between EasyFillHandler.js (field collection functions)
+     * and ObjectPageSectionHandler.js (section tree building), which has been deleted.
+     *
+     * All functions are stateless and receive required context via parameters.
+     */
+    return {
+
+        // ─── Field Mapping for LLM ───────────────────────────────────────────────
+
+        /**
+         * Builds the flat property map for the main entity type, used as the LLM input schema.
+         * Each entry contains the field label and OData data type.
+         *
+         * @param {object} oEntityType - OData entity type metadata object
+         * @param {object} oObjectPageContext - current ObjectPage binding context (used for visibility checks)
+         * @param {function} fnGetLabel - function(oProperty) → string label
+         * @returns {object} mPropertyMap keyed by property name
+         */
+        getEntitySetMap: function(oEntityType, oObjectPageContext, fnGetLabel) {
+            var mPropertyMap = {};
+            if (!oEntityType || !Array.isArray(oEntityType.property)) {
+                oLogger.warning("getEntitySetMap: no entity type or properties found");
+                return mPropertyMap;
+            }
+            oEntityType.property.forEach(function(oProperty) {
+                if (this.isVisible(oProperty, oObjectPageContext)) {
+                    mPropertyMap[oProperty.name] = {
+                        description: fnGetLabel(oProperty),
+                        dataType: oProperty.type
+                    };
+                }
+            }.bind(this));
+            return mPropertyMap;
+        },
+
+        /**
+         * Appends collection (SmartTable) field descriptors to an existing property map.
+         * Resets the collection context tracking maps before re-populating.
+         * Currently supports a single SmartTable (multi-table is a future enhancement).
+         *
+         * @param {object} mPropertyMap - the map to append to (mutated in place)
+         * @param {object} oObjectPage - the ObjectPage control (used to find SmartTables)
+         * @param {object} oObjectPageModel - the OData model of the ObjectPage
+         * @param {object} oTemplateUtils - FE template utilities (used for PresentationControlHandler)
+         * @param {object} mCollectionState - mutable collection state: { mCollectionRowContexts, mCollectionRowContextsByPath, mCollectionProperties, mCollectionEntityTypes, mCollectionEntitySets }
+         * @param {function} fnGetLabel - function(oProperty) → string label
+         */
+        appendCollectionMap: function(mPropertyMap, oObjectPage, oObjectPageModel, oTemplateUtils, mCollectionState, fnGetLabel) {
+            // Reset collection tracking before re-populating
+            mCollectionState.mCollectionRowContexts = Object.create(null);
+            mCollectionState.mCollectionRowContextsByPath = Object.create(null);
+            mCollectionState.mCollectionProperties = Object.create(null);
+            mCollectionState.mCollectionEntityTypes = Object.create(null);
+            mCollectionState.mCollectionEntitySets = Object.create(null);
+            mCollectionState.mCollectionAllowsCreation = Object.create(null);
+
+            var aSmartTables = this.getObjectPageSmartTables(oObjectPage);
+            if (!aSmartTables.length) {
+                oLogger.debug("appendCollectionMap: no SmartTables found on ObjectPage");
+                return;
+            }
+
+            var oMetaModel = oObjectPageModel && oObjectPageModel.getMetaModel();
+            if (!oMetaModel) {
+                oLogger.warning("appendCollectionMap: no MetaModel available");
+                return;
+            }
+
+            aSmartTables.forEach(function(oSmartTable) {
+                var oHandler = oTemplateUtils.oServices.oPresentationControlHandlerFactory.getPresentationControlHandler(oSmartTable);
+                if (!oHandler) {
+                    return;
+                }
+
+                // Navigation property name is derived from the binding path (e.g. "/to_Items" → "to_Items")
+                var sNavProperty = this._extractNavigationPropertyName(oHandler.getBindingPath());
+                if (!sNavProperty) {
+                    oLogger.warning("appendCollectionMap: could not extract nav property from binding path");
+                    return;
+                }
+
+                var aVisibleProps = (oHandler.findVisibleColumnProperties && oHandler.findVisibleColumnProperties()) || [];
+                if (!aVisibleProps.length) {
+                    return;
+                }
+
+                var aRowContexts = (oHandler.getCurrentContexts && oHandler.getCurrentContexts()) || [];
+                var sEntitySetName = oSmartTable.getEntitySet();
+                var oEntitySet = oMetaModel.getODataEntitySet(sEntitySetName);
+                var oEntityType = oEntitySet && oMetaModel.getODataEntityType(oEntitySet.entityType);
+                if (!oEntityType || !oEntityType.property) {
+                    return;
+                }
+
+                // Build a name→property lookup for this collection entity type
+                var mPropertyByName = Object.create(null);
+                oEntityType.property.forEach(function(oProperty) {
+                    mPropertyByName[oProperty.name] = oProperty;
+                });
+
+                // Build item-properties map for visible columns only
+                var oItemProperties = {};
+                aVisibleProps.forEach(function(sPropName) {
+                    var oProperty = mPropertyByName[sPropName];
+                    if (!oProperty) { return; }
+                    oItemProperties[sPropName] = {
+                        description: fnGetLabel(oProperty) || sPropName,
+                        dataType: oProperty.type
+                    };
+                });
+
+                if (!Object.keys(oItemProperties).length) {
+                    return;
+                }
+
+                // Build row data array for LLM context (current table rows with their values)
+                var aCurrentItems = [];
+                var mRowsByPath = Object.create(null);
+                aRowContexts.forEach(function(oContext, iIndex) {
+                    if (!oContext || !oContext.getObject) { return; }
+                    var sContextPath = oContext.getPath && oContext.getPath();
+                    var oRowData = { _rowIndex: iIndex };
+                    if (typeof sContextPath === "string") {
+                        oRowData._contextPath = sContextPath;
+                        mRowsByPath[sContextPath] = { context: oContext, rowIndex: iIndex };
+                    }
+                    Object.keys(oItemProperties).forEach(function(sPropName) {
+                        var vValue = oContext.getProperty(sPropName);
+                        if (typeof vValue !== "object") {
+                            oRowData[sPropName] = vValue;
+                        }
+                    });
+                    aCurrentItems.push(oRowData);
+                });
+
+                // Populate collection state tracking maps
+                mCollectionState.mCollectionRowContexts[sNavProperty] = aRowContexts;
+                mCollectionState.mCollectionRowContextsByPath[sNavProperty] = mRowsByPath;
+                mCollectionState.mCollectionProperties[sNavProperty] = mPropertyByName;
+                mCollectionState.mCollectionEntityTypes[sNavProperty] = oEntityType;
+                mCollectionState.mCollectionEntitySets[sNavProperty] = oEntitySet;
+                mCollectionState.mCollectionAllowsCreation[sNavProperty] = this.resolveTableAllowsCreation(oSmartTable);
+
+                // Add collection entry to the LLM field mapping
+                mPropertyMap[sNavProperty] = {
+                    description: typeof oSmartTable.getHeader() === "string" ? oSmartTable.getHeader() : sNavProperty,
+                    dataType: "Collection",
+                    isCollection: true,
+                    itemProperties: oItemProperties,
+                    currentItems: aCurrentItems,
+                    entitySet: sEntitySetName,
+                    section: typeof oSmartTable.getHeader() === "string" ? oSmartTable.getHeader() : sNavProperty
+                };
+            }.bind(this));
+        },
+
+        // ─── Updatable / Non-Updatable Classification ────────────────────────────
+
+        /**
+         * Splits LLM-returned simple fields into updatable and non-updatable buckets
+         * based on OData metadata annotations (sap:updatable, FieldControl, etc.).
+         *
+         * @param {object} oAiCallResult - flat map of { fieldName: aiValue } from the LLM
+         * @param {object} oEntityType - OData entity type metadata
+         * @param {object} oObjectPageContext - current ObjectPage binding context
+         * @param {object} oEntitySet - OData entity set metadata (for entity-set-level sap:updatable checks)
+         * @returns {{ updatableFields: object, nonUpdatableFields: object }}
+         */
+        getUpdatableAndNonUpdatableFields: function(oAiCallResult, oEntityType, oObjectPageContext, oEntitySet) {
+            var updatableFields = {};
+            var nonUpdatableFields = {};
+
+            if (!oEntityType || !Array.isArray(oEntityType.property)) {
+                oLogger.warning("getUpdatableAndNonUpdatableFields: no entity type available");
+                return { updatableFields: updatableFields, nonUpdatableFields: nonUpdatableFields };
+            }
+
+            Object.keys(oAiCallResult).forEach(function(sKey) {
+                var oProperty = oEntityType.property.find(function(oP) { return oP.name === sKey; });
+                if (!oProperty) {
+                    // Property not found in metadata → treat as non-updatable
+                    nonUpdatableFields[sKey] = oAiCallResult[sKey];
+                    return;
+                }
+                if (this.isEditable(oProperty, oObjectPageContext, oEntitySet)) {
+                    updatableFields[sKey] = oAiCallResult[sKey];
+                } else {
+                    nonUpdatableFields[sKey] = oAiCallResult[sKey];
+                }
+            }.bind(this));
+
+            return { updatableFields: updatableFields, nonUpdatableFields: nonUpdatableFields };
+        },
+
+        // ─── Visibility & Editability Checks ─────────────────────────────────────
+
+        /**
+         * Checks whether a property should be included in the LLM field mapping.
+         * Evaluates UI.Hidden, FieldControl (Hidden), and sap:field-control annotations.
+         *
+         * @param {object} oProperty - OData property metadata
+         * @param {object} oObjectPageContext - current ObjectPage binding context
+         * @returns {boolean}
+         */
+        isVisible: function(oProperty, oObjectPageContext) {
+            // Check "com.sap.vocabularies.Common.v1.FieldControl" for Hidden enum
+            var oAnnotation = oProperty["com.sap.vocabularies.Common.v1.FieldControl"];
+            if (oAnnotation && oAnnotation["EnumMember"]) {
+                return oAnnotation["EnumMember"] !== "com.sap.vocabularies.Common.v1.FieldControlType/Hidden";
+            }
+
+            // Check "com.sap.vocabularies.UI.v1.Hidden" annotation
+            var oHiddenAnnotation = oProperty["com.sap.vocabularies.UI.v1.Hidden"];
+            if (oHiddenAnnotation) {
+                if (oHiddenAnnotation["Bool"]) {
+                    return oHiddenAnnotation["Bool"] !== "true";
+                }
+                if (oHiddenAnnotation["Path"] && oObjectPageContext) {
+                    return !oObjectPageContext.getObject()[oHiddenAnnotation["Path"]];
+                }
+                // <Annotation Term="UI.Hidden"/> with no value → hidden
+                return false;
+            }
+
+            // Check "sap:field-control" attribute (value 0 = hidden)
+            var sFieldControl = oProperty["sap:field-control"];
+            if (sFieldControl && oObjectPageContext) {
+                var iFieldControlValue = oObjectPageContext.getObject()[sFieldControl];
+                return iFieldControlValue !== 0;
+            }
+
+            // No restriction → visible by default
+            return true;
+        },
+
+        /**
+         * Checks whether a property is editable based on OData annotations.
+         * Uses the current ObjectPage context object for dynamic field-control checks.
+         *
+         * Priority: entity-set-level sap:updatable → property sap:updatable → FieldControl (EnumMember) → sap:field-control (dynamic value)
+         *
+         * Field control values:
+         *   0 = Hidden, 1 = ReadOnly, 3 = Editable, 7 = Mandatory (editable)
+         *
+         * @param {object} oProperty - OData property metadata
+         * @param {object} oObjectPageContext - current ObjectPage binding context
+         * @param {object} oEntitySet - optional OData entity set metadata (for entity-set-level checks)
+         * @returns {boolean}
+         */
+        isEditable: function(oProperty, oObjectPageContext, oEntitySet) {
+            var oContextObject = oObjectPageContext && oObjectPageContext.getObject && oObjectPageContext.getObject();
+            return this.isEditableByContextObject(oProperty, oContextObject, oEntitySet);
+        },
+
+        /**
+         * Checks editability given a plain context data object (not a binding context).
+         * Used for both entity-level and collection-row-level editability checks.
+         *
+         * @param {object} oProperty - OData property metadata
+         * @param {object} oContextObject - plain JS object of the current row/entity data
+         * @param {object} oEntitySet - optional OData entity set metadata (for entity-set-level checks)
+         * @returns {boolean}
+         */
+        isEditableByContextObject: function(oProperty, oContextObject, oEntitySet) {
+            if (!oProperty) {
+                return false;
+            }
+
+            // Check entity-set-level sap:updatable (entire entity set is read-only)
+            if (oEntitySet) {
+                var sEntitySetUpdatable = oEntitySet["sap:updatable"];
+                if (sEntitySetUpdatable === "false") {
+                    return false;
+                }
+                // sap:updatable-path: resolved against the context object (boolean property)
+                var sEntitySetUpdatablePath = oEntitySet["sap:updatable-path"];
+                if (sEntitySetUpdatablePath && oContextObject) {
+                    var bUpdatableFromPath = oContextObject[sEntitySetUpdatablePath];
+                    if (bUpdatableFromPath === false || bUpdatableFromPath === "false") {
+                        return false;
+                    }
+                }
+            }
+
+            // Check sap:updatable — static annotation on the property
+            var sUpdatable = oProperty["sap:updatable"];
+            if (sUpdatable) {
+                return sUpdatable !== "false";
+            }
+
+            // Check "com.sap.vocabularies.Common.v1.FieldControl" enum member
+            var oAnnotation = oProperty["com.sap.vocabularies.Common.v1.FieldControl"];
+            if (oAnnotation && oAnnotation["EnumMember"]) {
+                return oAnnotation["EnumMember"] !== "com.sap.vocabularies.Common.v1.FieldControlType/ReadOnly";
+            }
+
+            // Check "sap:field-control" dynamic path (value 1 = read-only)
+            var sFieldControl = oProperty["sap:field-control"];
+            if (sFieldControl) {
+                var iFieldControlValue = oContextObject && oContextObject[sFieldControl];
+                return iFieldControlValue !== 1;
+            }
+
+            // No restriction → editable by default
+            return true;
+        },
+
+        // ─── Section Tree Building (from ObjectPageSectionHandler) ───────────────
+
+        /**
+         * Builds a flat section tree for the Condensed view mode.
+         * Creates two sections: "Filled Fields" (updatable) and "Unfilled Fields" (non-updatable).
+         *
+         * @param {object} oLLMResult - flat map of { fieldName: value } from the LLM
+         * @param {object} oUpdatableFields - flat map of updatable fields only
+         * @param {object} oNonUpdatableFields - flat map of non-updatable fields only
+         * @returns {Array} section tree array
+         */
+        getSectionsForCondensedView: function(oLLMResult, oUpdatableFields, oNonUpdatableFields) {
+            var aUpdatableKeys = Object.keys(oUpdatableFields || {});
+            var aNonUpdatableKeys = Object.keys(oNonUpdatableFields || {});
+            var aSections = [];
+            // Section 1: Filled Fields (updatable)
+            if (aUpdatableKeys.length > 0) {
+                aSections.push({
+                    title: "{@i18n>EASY_FILL_FILLED_FIELDS}",
+                    fields: [],
+                    children: [{
+                        title: "",
+                        fields: aUpdatableKeys,
+                        id: this._generateId("filledFields", aUpdatableKeys)
+                    }]
+                });
+            }
+
+            // Section 2: Unfilled Fields (non-updatable/read-only)
+            if (aNonUpdatableKeys.length > 0) {
+                aSections.push({
+                    title: "{@i18n>EASY_FILL_UNFILLED_FIELDS}",
+                    fields: [],
+                    children: [{
+                        title: "",
+                        fields: aNonUpdatableKeys,
+                        id: this._generateId("unfilledFields", aNonUpdatableKeys)
+                    }]
+                });
+            }
+
+            // Fallback: if no split provided, use old behavior
+            if (aSections.length === 0) {
+                return this._transformToTreeExpanded(oLLMResult);
+            }
+
+            return aSections;
+        },
+
+        /**
+         * Builds a structured section tree for the ObjectPage view mode.
+         * Mirrors the ObjectPage section/facet structure and filters to only include
+         * updatable fields returned by the LLM. Non-updatable (read-only) fields are
+         * excluded from the annotation sections and shown exclusively in the
+         * "Unfilled Fields" section appended at the end.
+         *
+         * @param {object} oEntityType - OData entity type metadata
+         * @param {object} oLLMResult - flat map of { fieldName: value } from the LLM
+         * @param {object} oRb - i18n resource bundle
+         * @param {object} oNonUpdatableFields - flat map of non-updatable fields only (optional)
+         * @returns {Array} filtered section tree array
+         */
+        getSectionsForObjectPageView: function(oEntityType, oLLMResult, oRb, oNonUpdatableFields) {
+            var aSections = [];
+            aSections = aSections
+                .concat(this._getSectionsForHeader(oEntityType, oRb))
+                .concat(this._getSectionsForObjectPageFacets(oEntityType));
+            var aTree = this._transformToTree(aSections);
+
+            // Annotation sections must only show updatable fields.
+            // Derive the updatable-only subset by removing non-updatable keys from oLLMResult
+            // so non-updatable fields do not appear in both annotation sections AND Unfilled Fields.
+            var aNonUpdatableSet = Object.keys(oNonUpdatableFields || {});
+            var oUpdatableResult = Object.keys(oLLMResult).reduce(function(oAcc, sKey) {
+                if (aNonUpdatableSet.indexOf(sKey) === -1) {
+                    oAcc[sKey] = oLLMResult[sKey];
+                }
+                return oAcc;
+            }, {});
+            var aFilteredTree = this._filterTreeByLLMResult(aTree, oUpdatableResult);
+            aFilteredTree = this._flattenTreeForObjectPageDialog(aFilteredTree);
+
+            // "Unfilled Fields" contains only non-updatable (read-only) fields.
+            // Editable fields that have no annotation section are silently dropped here —
+            // they already appear in their respective annotation-matched sections above.
+            var aNonUpdatableKeys = Object.keys(oNonUpdatableFields || {});
+            if (aNonUpdatableKeys.length > 0) {
+                aFilteredTree.push({
+                    title: "{@i18n>EASY_FILL_UNFILLED_FIELDS}",
+                    fields: [],
+                    children: [{
+                        title: "",
+                        fields: aNonUpdatableKeys,
+                        id: this._generateId("unfilledFields", aNonUpdatableKeys)
+                    }]
+                });
+            }
+
+            return aFilteredTree;
+        },
+
+        // ─── SmartTable Utilities ─────────────────────────────────────────────────
+
+        /**
+         * Finds all SmartTable instances on the ObjectPage that are of a supported type
+         * (Responsive Table or UI5 Grid Table).
+         *
+         * @param {object} oObjectPage - the ObjectPage control
+         * @returns {Array} array of sap.ui.comp.smarttable.SmartTable controls
+         */
+        getObjectPageSmartTables: function(oObjectPage) {
+            if (!oObjectPage || !oObjectPage.findAggregatedObjects) {
+                return [];
+            }
+            // Note: Currently restricted to Responsive and Grid tables.
+            // Custom SmartTables are also included — future work should filter
+            // to only annotation-defined tables to avoid false positives.
+            return oObjectPage.findAggregatedObjects(true, function(oControl) {
+                var bIsSmartTable = controlHelper.isSmartTable(oControl);
+                return bIsSmartTable && (
+                    oControl.getTable().isA("sap.m.Table") ||
+                    oControl.getTable().isA("sap.ui.table.Table")
+                );
+            }) || [];
+        },
+
+        /**
+         * Validates whether a given entity set name corresponds to a known SmartTable on the page.
+         *
+         * @param {string} sEntitySet - entity set name to validate
+         * @param {object} oObjectPage - the ObjectPage control
+         * @returns {{ isValid: boolean, smartTable: object|undefined }}
+         */
+        isValidSmartTable: function(sEntitySet, oObjectPage) {
+            var aSmartTables = this.getObjectPageSmartTables(oObjectPage);
+            var oSmartTable = aSmartTables.find(function(oTable) {
+                return oTable.getEntitySet() === sEntitySet;
+            });
+            return {
+                isValid: !!oSmartTable,
+                smartTable: oSmartTable
+            };
+        },
+
+        /**
+         * Determines whether a SmartTable supports creation of new rows via inline mode.
+         * Supports "inline" createMode (with an enabled Create toolbar button) and
+         * "creationRows" / "creationRowsHiddenInEditMode" createMode (InlineCreationRows).
+         *
+         * @param {object} oSmartTable - sap.ui.comp.smarttable.SmartTable control
+         * @returns {boolean} true if new rows can be created for this table
+         */
+        resolveTableAllowsCreation: function(oSmartTable) {
+            var sCreateMode = oSmartTable.data("creationMode");
+            var bIsInlineCreationRows = sCreateMode === "creationRows" || sCreateMode === "creationRowsHiddenInEditMode";
+            var bIsInline = sCreateMode === "inline";
+
+            if (bIsInlineCreationRows) {
+                return true;
+            }
+
+            if (bIsInline) {
+                // Inline create requires the Create toolbar button to be enabled
+                var oTable = oSmartTable.getTable && oSmartTable.getTable();
+                if (!oTable) {
+                    return false;
+                }
+                var oToolbar = oSmartTable.getCustomToolbar && oSmartTable.getCustomToolbar();
+                if (!oToolbar) {
+                    return false;
+                }
+                var aButtons = oToolbar.getContent && oToolbar.getContent();
+                if (!Array.isArray(aButtons)) {
+                    return false;
+                }
+                var oCreateButton = aButtons.find(function(oControl) {
+                    return oControl.isA && oControl.isA("sap.m.Button") &&
+                        typeof oControl.getId === "function" &&
+                        oControl.getId().indexOf("add") >= 0 &&
+                        oControl.getEnabled && oControl.getEnabled();
+                });
+                return !!oCreateButton;
+            }
+
+            return false;
+        },
+
+        // ─── Private Helpers ─────────────────────────────────────────────────────
+
+        /**
+         * Extracts the navigation property name from an OData binding path.
+         * E.g. "/to_Items" → "to_Items", "/SalesOrderSet/to_Items" → "to_Items"
+         *
+         * @param {string} sBindingPath
+         * @returns {string|null}
+         */
+        _extractNavigationPropertyName: function(sBindingPath) {
+            if (!sBindingPath || typeof sBindingPath !== "string") {
+                return null;
+            }
+            var aParts = sBindingPath.split("/").filter(Boolean);
+            return aParts.length ? aParts[aParts.length - 1] : null;
+        },
+
+        /**
+         * Builds the "condensed" tree: all LLM fields in a single flat group.
+         * @private
+         */
+        _transformToTreeExpanded: function(oLLMRes) {
+            return [
+                {
+                    title: "",
+                    fields: [],
+                    children: [{
+                        title: "",
+                        fields: Object.keys(oLLMRes),
+                        id: this._generateId("", Object.keys(oLLMRes))
+                    }]
+                }
+            ];
+        },
+
+        /**
+         * Builds the "ObjectPage" section tree from a flat array of { title[], property } entries.
+         * Groups entries by their title path hierarchy.
+         * @private
+         */
+        _transformToTree: function(data) {
+            var rootMap = {};
+            var seen = new Set();
+            var that = this;
+
+            data.forEach(function(entry) {
+                var title = entry.title;
+                var property = entry.property;
+                if (seen.has(property)) { return; }
+                seen.add(property);
+
+                var currentMap = rootMap;
+                var sTitlePath = "";
+
+                title.forEach(function(level, index) {
+                    var isLast = index === title.length - 1;
+                    sTitlePath = sTitlePath ? (sTitlePath + "_" + level) : level;
+
+                    if (!currentMap[level]) {
+                        currentMap[level] = {
+                            title: level,
+                            titlePath: sTitlePath,
+                            fields: [],
+                            _childrenMap: {}
+                        };
+                    }
+
+                    if (isLast) {
+                        currentMap[level].fields.push(property);
+                    } else {
+                        currentMap = currentMap[level]._childrenMap;
+                    }
+                });
+            });
+
+            function convertToArray(oMap) {
+                return Object.values(oMap).map(function(oNode) {
+                    return {
+                        title: oNode.title,
+                        id: that._generateId(oNode.titlePath, oNode.fields),
+                        fields: oNode.fields,
+                        children: oNode._childrenMap ? convertToArray(oNode._childrenMap) : []
+                    };
+                });
+            }
+
+            return convertToArray(rootMap);
+        },
+
+        /**
+         * Generates a stable DOM-safe ID for a SmartForm section based on its title path and fields.
+         * @private
+         */
+        _generateId: function(sTitlePath, aFields) {
+            var sSanitizedTitle = sTitlePath
+                .replace(/\s+/g, "_")
+                .replace(/[^a-zA-Z0-9_]/g, "")
+                .toLowerCase();
+            var sFieldsPart = aFields
+                .join("_")
+                .replace(/[^a-zA-Z0-9_]/g, "")
+                .toLowerCase();
+            return "EasyFillSmartForm_" + sSanitizedTitle + (sFieldsPart ? "_" + sFieldsPart : "");
+        },
+
+        /**
+         * Filters a section tree to only include nodes that contain at least one LLM-returned field.
+         * Fields with no matching annotation section are silently dropped; the caller is responsible
+         * for surfacing them elsewhere (e.g. the "unfilledFields" section for non-updatable fields).
+         *
+         * @param {Array} aTree - section tree
+         * @param {object} oLLMResult - flat map of all LLM fields
+         * @returns {Array} filtered tree
+         * @private
+         */
+        _filterTreeByLLMResult: function(aTree, oLLMResult) {
+            var aRequestedKeys = Object.keys(oLLMResult);
+            var that = this;
+
+            function filterNode(oNode, sParentPath) {
+                var sTitlePath = sParentPath ? (sParentPath + "_" + oNode.title) : oNode.title;
+
+                var aFilteredFields = oNode.fields.filter(function(sField) {
+                    return aRequestedKeys.includes(sField);
+                });
+
+                var aFilteredChildren = oNode.children
+                    .map(function(oChild) { return filterNode(oChild, sTitlePath); })
+                    .filter(function(oChild) { return oChild.fields.length > 0 || oChild.children.length > 0; });
+
+                return {
+                    title: oNode.title,
+                    id: that._generateId(sTitlePath, aFilteredFields),
+                    fields: aFilteredFields,
+                    children: aFilteredChildren
+                };
+            }
+
+            return aTree
+                .map(function(oNode) { return filterNode(oNode, ""); })
+                .filter(function(oNode) { return oNode.fields.length > 0 || oNode.children.length > 0; });
+        },
+
+        /**
+         * Flattens nested ObjectPage section trees to one group level expected by the dialog fragment.
+         *
+         * EasyFill dialog binds SmartForm groups only to section.children (one level deep).
+         * If annotation facets produce deeper nesting, section titles can render while fields remain
+         * invisible because grandchildren are never bound as groups.
+         *
+         * @param {Array} aTree - filtered section tree
+         * @returns {Array} dialog-compatible tree with one-level children per section
+         * @private
+         */
+        _flattenTreeForObjectPageDialog: function(aTree) {
+            var that = this;
+
+            function collectRenderableGroups(oNode, sParentPath) {
+                var sTitlePath = sParentPath ? (sParentPath + "_" + oNode.title) : oNode.title;
+                var aGroups = [];
+
+                if (Array.isArray(oNode.fields) && oNode.fields.length > 0) {
+                    aGroups.push({
+                        title: oNode.title,
+                        id: that._generateId(sTitlePath, oNode.fields),
+                        fields: oNode.fields,
+                        children: []
+                    });
+                }
+
+                if (Array.isArray(oNode.children) && oNode.children.length > 0) {
+                    oNode.children.forEach(function(oChild) {
+                        aGroups = aGroups.concat(collectRenderableGroups(oChild, sTitlePath));
+                    });
+                }
+
+                return aGroups;
+            }
+
+            return (aTree || []).map(function(oSection) {
+                var sSectionPath = oSection.title || "";
+                return {
+                    title: oSection.title,
+                    id: oSection.id,
+                    fields: [],
+                    children: collectRenderableGroups(oSection, sSectionPath)
+                };
+            }).filter(function(oSection) {
+                return Array.isArray(oSection.children) && oSection.children.length > 0;
+            });
+        },
+
+        /**
+         * Extracts section entries from ObjectPage header annotations (HeaderInfo + HeaderFacets).
+         * @private
+         */
+        _getSectionsForHeader: function(oEntityType, oRb) {
+            var aRes = [];
+            var oHeaderInfo = oEntityType["com.sap.vocabularies.UI.v1.HeaderInfo"];
+            var aHeaderFacets = oEntityType["com.sap.vocabularies.UI.v1.HeaderFacets"];
+
+            if (oHeaderInfo && Object.keys(oHeaderInfo).length > 0) {
+                var aKeys = Object.keys(oHeaderInfo).filter(function(sKey) {
+                    return oHeaderInfo[sKey].RecordType === "com.sap.vocabularies.UI.v1.DataField";
+                });
+                aKeys.forEach(function(sKey) {
+                    aRes.push({
+                        title: [oRb.getText("EASY_FILL_SECTION_HEADER"), oRb.getText("EASY_FILL_SECTION_HEADER")],
+                        property: oHeaderInfo[sKey].Value.Path
+                    });
+                });
+            }
+
+            if (aHeaderFacets && aHeaderFacets.length > 0) {
+                var aSections = this._extractSectionInfoFromReferenceFacet(oEntityType, aHeaderFacets);
+                aSections.forEach(function(oSection) {
+                    oSection.title = [oRb.getText("EASY_FILL_SECTION_HEADER"), oRb.getText("EASY_FILL_SECTION_HEADER")];
+                });
+                aRes.push.apply(aRes, aSections);
+            }
+
+            return aRes;
+        },
+
+        /**
+         * Extracts section entries from the main ObjectPage facet annotations (UI.Facets).
+         * @private
+         */
+        _getSectionsForObjectPageFacets: function(oEntityType) {
+            var aSectionFacets = oEntityType["com.sap.vocabularies.UI.v1.Facets"];
+            if (aSectionFacets && aSectionFacets.length > 0) {
+                return this._extractFacetInfoRecursively(oEntityType, aSectionFacets, []);
+            }
+            return [];
+        },
+
+        /**
+         * Recursively walks CollectionFacets and ReferenceFacets to extract { title, property } pairs.
+         * @private
+         */
+        _extractFacetInfoRecursively: function(oEntityType, aFacets, aTitle) {
+            var aRes = [];
+            aFacets.forEach(function(oFacet) {
+                if (oFacet.RecordType === "com.sap.vocabularies.UI.v1.CollectionFacet") {
+                    var aInnerFacets = oFacet.Facets;
+                    if (aInnerFacets && aInnerFacets.length > 0) {
+                        var sLabel = oFacet.Label && oFacet.Label.String ? oFacet.Label.String : null;
+                        aRes = aRes.concat(this._extractFacetInfoRecursively(
+                            oEntityType,
+                            aInnerFacets,
+                            sLabel ? aTitle.concat(sLabel) : aTitle
+                        ));
+                    }
+                } else {
+                    aRes = aRes.concat(this._extractSectionInfoFromReferenceFacet(oEntityType, [oFacet], aTitle));
+                }
+            }.bind(this));
+            return aRes;
+        },
+
+        /**
+         * Extracts { title[], property } entries from a set of ReferenceFacets.
+         * Skips IntentBasedNavigation, ForAction, and ForAnnotation record types (not supported).
+         * @private
+         */
+        _extractSectionInfoFromReferenceFacet: function(oEntityType, aFacets, aText) {
+            aText = aText || [];
+            var aRes = [];
+            aFacets.forEach(function(oFacet) {
+                // Skip unsupported annotation types
+                if (!this._isSupportedRecordType(oFacet.RecordType)) {
+                    return;
+                }
+
+                var aTempText = aText.slice();
+                var sAnnotationPath = oFacet.Target.AnnotationPath.substring(1);
+                var oAnnotation = oEntityType[sAnnotationPath];
+                var sTitle = null;
+
+                // Title resolution priority: Facet.Label → Annotation.Label → Facet.Title → Annotation.Title
+                if (oFacet && oFacet.Label) {
+                    sTitle = oFacet.Label.String;
+                } else if (oAnnotation && oAnnotation.Label) {
+                    sTitle = oAnnotation.Label.String;
+                } else if (oFacet && oFacet.Title) {
+                    sTitle = oFacet.Title.String;
+                } else if (oAnnotation && oAnnotation.Title) {
+                    sTitle = oAnnotation.Title.String;
+                }
+
+                if (sTitle) {
+                    aTempText.push(sTitle);
+                }
+
+                if (oAnnotation) {
+                    if (oAnnotation.Data) {
+                        // FieldGroup / Form — iterate Data array
+                        oAnnotation.Data.forEach(function(oData) {
+                            if (!this._isSupportedRecordType(oData.RecordType)) { return; }
+                            if (!oData.Value || !oData.Value.Path) { return; }
+                            aRes.push({ title: aTempText, property: oData.Value.Path });
+                        }.bind(this));
+                    } else if (Array.isArray(oAnnotation)) {
+                        // LineItem — iterate annotation array directly
+                        oAnnotation.forEach(function(oAnno) {
+                            if (!this._isSupportedRecordType(oAnno.RecordType)) { return; }
+                            if (!oAnno.Value || !oAnno.Value.Path) { return; }
+                            aRes.push({ title: aTempText, property: oAnno.Value.Path });
+                        }.bind(this));
+                    } else if (oAnnotation.Value && oAnnotation.Value.Path) {
+                        // Single-value annotation (e.g. DataPoint)
+                        aRes.push({ title: aTempText, property: oAnnotation.Value.Path });
+                    }
+                }
+            }.bind(this));
+            return aRes;
+        },
+
+        /**
+         * Returns false for record types that EasyFill does not support rendering.
+         * Currently excludes: IntentBasedNavigation, ForAnnotation, ForAction.
+         * Handles both fully-qualified names (com.sap.vocabularies.UI.v1.*) and
+         * alias form (UI.*) that OData metadata can return depending on the service.
+         * @private
+         */
+        _isSupportedRecordType: function(sRecordType) {
+            if (!sRecordType) { return false; }
+            var sNormalized = sRecordType.replace("com.sap.vocabularies.UI.v1.", "UI.");
+            return sNormalized !== "UI.DataFieldForIntentBasedNavigation" &&
+                   sNormalized !== "UI.DataFieldForAnnotation" &&
+                   sNormalized !== "UI.DataFieldForAction" &&
+                   sNormalized !== "UI.DataFieldWithNavigationPath" &&
+                   sNormalized !== "UI.DataFieldWithIntentBasedNavigation";
+        }
+    };
+});