@sapui5/sap.fe.templates 1.147.0 → 1.148.1

package/src/sap/fe/templates/ObjectPage/ObjectPageController.controller.ts

@@ -25,6 +25,7 @@ import NavigationReason from "sap/fe/core/controllerextensions/routing/Navigatio
 import type CommandExecution from "sap/fe/core/controls/CommandExecution";
 import { RecommendationDialogDecision } from "sap/fe/core/controls/Recommendations/ConfirmRecommendationDialog";
 import type { HiddenDraft, MicroChartManifestConfiguration } from "sap/fe/core/converters/ManifestSettings";
+import { CreationMode } from "sap/fe/core/converters/ManifestSettings";
 import type { InternalModelContext } from "sap/fe/core/helpers/ModelHelper";
 import ModelHelper from "sap/fe/core/helpers/ModelHelper";
 import FELibrary from "sap/fe/core/library";
@@ -48,6 +49,7 @@ import type { default as ObjectPageExtensionAPI } from "sap/fe/templates/ObjectP
 import { default as ExtensionAPI } from "sap/fe/templates/ObjectPage/ExtensionAPI";
 import CollaborationDiscard from "sap/fe/templates/ObjectPage/components/CollaborationDiscardDialog";
 import type SubSectionBlock from "sap/fe/templates/ObjectPage/controls/SubSectionBlock";
+import { pollForSectionStability } from "sap/fe/templates/ObjectPage/helpers/SectionNavigationHelper";
 import TableScroller from "sap/fe/templates/TableScroller";
 import type Button from "sap/m/Button";
 import type InputBase from "sap/m/InputBase";
@@ -55,6 +57,7 @@ import InstanceManager from "sap/m/InstanceManager";
 import type MenuButton from "sap/m/MenuButton";
 import type NavContainer from "sap/m/NavContainer";
 import type Popover from "sap/m/Popover";
+import type SearchField from "sap/m/SearchField";
 import type ToolbarSpacer from "sap/m/ToolbarSpacer";
 import Device from "sap/ui/Device";
 import type UI5Event from "sap/ui/base/Event";
@@ -104,6 +107,8 @@ export type BindingParams = {
 	bPersistOPScroll?: boolean;
 	listBinding?: ODataListBinding;
 	showPlaceholder?: boolean;
+	requestOnBinding?: string[];
+	targetControlId?: string;
 };
 
 const ProgrammingModel = FELibrary.ProgrammingModel;
@@ -189,6 +194,16 @@ class ObjectPageController extends PageController {
 
 	private previousBindingContextPath?: string;
 
+	private pendingTargetControlId?: string;
+
+	private targetSubSection?: ObjectPageSubSection;
+
+	// Flag to prevent ViewState.apply() from overriding section selection after user interaction or targetControlId navigation
+	private skipViewStateSectionRestore = false;
+
+	// Tracks if the binding context path changed (new entity vs same entity re-binding)
+	private isNewBindingContext = false;
+
 	/**
 	 * Returns controls (Button / MenuButton) that are marked as "primary action".
 	 * The marker is set by the converters when an action is emphasized (annotation-based) or
@@ -346,10 +361,14 @@ class ObjectPageController extends PageController {
 				}
 				const tableType = table.isA<Table>("sap.ui.mdc.Table") && (table.getType() as TableTypeBase);
 				const tableAPI = table.getParent()?.isA<TableAPI>("sap.fe.macros.Table") ? (table.getParent() as TableAPI) : undefined;
+				const tableControl = tableAPI?.getTableDefinition().control;
+
 				if (
 					tableType &&
 					(tableType?.isA("sap.ui.mdc.table.GridTableType") || tableType?.isA("sap.ui.mdc.table.TreeTableType")) &&
-					tableAPI?.getTableDefinition().control.rowCountMode === "Auto"
+					tableControl?.rowCountMode === "Auto" &&
+					// Exclude CreationRow mode unless sectionLayout is Tabs: the fit-container style creates whitespace in the subsection in edit mode when CreationRow is used in TableCreationOptions
+					(tableControl?.creationMode !== CreationMode.CreationRow || this.getView().getViewData().sectionLayout === "Tabs")
 				) {
 					//In case there is only a single table in a subSection we fit that to the whole page so that the scrollbar comes only on table and not on page
 					visibleSubSection.addStyleClass("sapUxAPObjectPageSubSectionFitContainer");
@@ -429,8 +448,30 @@ class ObjectPageController extends PageController {
 	}
 
 	_onBeforeBinding(oContext: ODataV4Context, mParameters: BindingParams = {}): void {
-		// TODO: we should check how this comes together with the transaction helper, same to the change in the afterBinding
-		this.previousBindingContextPath = this.getView().getBindingContext()?.getPath();
+		// Reset flag to allow section restoration on this new binding context.
+		// This ensures ViewState.apply() can properly restore sections after discard or re-navigation.
+		this.skipViewStateSectionRestore = false;
+
+		// Store targetControlId for scrolling after binding completes
+		this.pendingTargetControlId = mParameters.targetControlId;
+
+		// Apply targetControlId only on initial navigation - don't apply during edit/save/discard transitions
+		// to preserve user's section selection. Note: getView().getBindingContext() returns the OLD context
+		// therefore the oContext parameter is used.
+		const currentContextPath = oContext?.getPath();
+		const getEntityIdentity = (path: string | undefined): string | undefined => {
+			if (!path) return undefined;
+			// Remove IsActiveEntity from the path to get entity identity
+			// e.g., "/Products(ID=1,IsActiveEntity=true)" -> "/Products(ID=1)"
+			return path
+				.replace(/,?IsActiveEntity=(true|false),?/, "")
+				.replace(/\(\s*,/, "(")
+				.replace(/,\s*\)/, ")");
+		};
+		const currentEntityId = getEntityIdentity(currentContextPath);
+		const previousEntityId = getEntityIdentity(this.previousBindingContextPath);
+		this.isNewBindingContext = previousEntityId !== currentEntityId;
+		this.previousBindingContextPath = currentContextPath;
 		const aTables = this._findTables(),
 			oObjectPage = this._getObjectPageLayoutControl(),
 			oInternalModelContext = this.getView().getBindingContext("internal") as InternalModelContext,
@@ -690,6 +731,7 @@ class ObjectPageController extends PageController {
 	/**
 	 * Set the initial focus in edit mode.
 	 * @param aSubSections Object page sub sections
+	 * @param fromTabNavigation Indicates if the focus is set after a tab navigation
 	 */
 	_updateFocusInEditMode(aSubSections: ObjectPageSubSection[], fromTabNavigation = false): void {
 		setTimeout(
@@ -697,7 +739,7 @@ class ObjectPageController extends PageController {
 				// We set the focus in a timeeout, otherwise the focus sometimes goes to the TabBar
 				const oObjectPage = this._getObjectPageLayoutControl();
 				const oMandatoryField = this._getFirstEmptyMandatoryFieldFromSubSection(aSubSections);
-				let oFieldToFocus;
+				let oFieldToFocus: UI5Element | undefined;
 				if (oMandatoryField) {
 					if (oMandatoryField.isA("sap.fe.macros.MultiValueField")) {
 						oFieldToFocus = (oMandatoryField as unknown as MultiValueFieldBlock).getMultiValueField();
@@ -713,9 +755,22 @@ class ObjectPageController extends PageController {
 					const focusInfo = oFieldToFocus.getFocusInfo() as { targetInfo: object };
 					focusInfo.targetInfo = { silent: true };
 					if (oFieldToFocus.isA("sap.ui.mdc.field.FieldInput")) {
-						oFieldToFocus = oFieldToFocus.getParent();
+						oFieldToFocus = oFieldToFocus.getParent() as UI5Element | undefined;
+					}
+
+					if (
+						oFieldToFocus?.isA<SearchField>("sap.m.SearchField") &&
+						oFieldToFocus.getEnableSuggestions() &&
+						!oFieldToFocus.isBound("enableSuggestions")
+					) {
+						// In case the focus is set on a search field with suggestions, we temporarily disable the suggestions to avoid triggering them on focus
+						// unless this property is bound (to avoid modifying something in a model)
+						oFieldToFocus.setEnableSuggestions(false);
+						oFieldToFocus.focus(focusInfo);
+						oFieldToFocus.setEnableSuggestions(true);
+					} else {
+						oFieldToFocus?.focus(focusInfo);
 					}
-					oFieldToFocus.focus(focusInfo);
 				}
 			}.bind(this),
 			fromTabNavigation ? 300 : 0
@@ -777,15 +832,24 @@ class ObjectPageController extends PageController {
 
 		// Function to navigate back, or display the launchpad if we're on the first page of the history
 		const navBack = (): void => {
-			const currentURL = document.URL;
-			history.back();
-			// In case there is no previous page in the history, history.back does nothing.
-			// In this case, we need to use navigateBackFromContext, that will display the home page
-			setTimeout(() => {
-				if (document.URL === currentURL) {
-					this._routing.navigateBackFromContext(oContext);
-				}
-			}, 500);
+			// Use the new Navigation API if it's available in the browser, to check if we can go back in history.
+			const canGoBack = (window as { navigation?: { canGoBack?: boolean } }).navigation?.canGoBack;
+			if (canGoBack === true) {
+				history.back();
+			} else if (canGoBack === false) {
+				this._routing.navigateBackFromContext(oContext);
+			} else {
+				// Fallback in case the browser doesn't support the Navigation API
+				const currentURL = document.URL;
+				history.back();
+				// In case there is no previous page in the history, history.back does nothing.
+				// In this case, we need to use navigateBackFromContext, that will display the home page
+				setTimeout(() => {
+					if (document.URL === currentURL) {
+						this._routing.navigateBackFromContext(oContext);
+					}
+				}, 500);
+			}
 		};
 
 		if (this.getAppComponent().getRouterProxy().checkIfBackHasSameContext()) {
@@ -826,7 +890,7 @@ class ObjectPageController extends PageController {
 			this.editFlow.storeSiblingContextData(inputBindingContext);
 		}
 
-		this._sideEffects.clearFieldGroupsValidity();
+		this.sideEffects.clearFieldGroupsValidity();
 
 		// TODO: this is only a temp solution as long as the model fix the cache issue and we use this additional
 		// binding with ownRequest
@@ -984,6 +1048,140 @@ class ObjectPageController extends PageController {
 			applyAppState,
 			this.previousBindingContextPath !== this.getView().getBindingContext()?.getPath()
 		);
+
+		// Capture synchronously to avoid race with subsequent navigations
+		const pendingTargetControlId = this.pendingTargetControlId;
+		this.pendingTargetControlId = undefined;
+
+		this.handlePendingTargetControlIdNavigation(applyAppState, oObjectPage, pendingTargetControlId);
+	}
+
+	/**
+	 * Handles navigation to a target section or subsection after app state is applied.
+	 * This coordinates targetControlId navigation from two sources:
+	 * - In-app navigation: pendingTargetControlId captured before applyAppState.
+	 * - Cross-app navigation: xAppState targetControlId stored by AppStateHandler during LR to OP transition.
+	 * @param applyAppState Promise that resolves when app state has been applied.
+	 * @param oObjectPage The ObjectPageLayout control.
+	 * @param pendingTargetControlId The targetControlId captured before applyAppState, if any.
+	 */
+	private handlePendingTargetControlIdNavigation(
+		applyAppState: Promise<void | object>,
+		oObjectPage: ObjectPageLayout,
+		pendingTargetControlId: string | undefined
+	): void {
+		applyAppState
+			.then(async () => {
+				const xAppStateTargetControlId = this.getAppComponent().getAppStateHandler()?.consumePendingTargetControlId();
+				const targetControlId = pendingTargetControlId ?? xAppStateTargetControlId;
+				if (!targetControlId) {
+					return;
+				}
+
+				// Wait for visibility bindings  (needed for lazy loading scenarios)
+				try {
+					await Promise.all(this.waitForVisibilityBindings);
+				} catch {
+					// Some visibility bindings failed to resolve, proceeding anyway
+				}
+
+				// Wait for pageReady to ensure ObjectPage is fully initialized
+				await this.pageReady.waitPageReady();
+
+				// Navigate to target section
+				this.navigateToTargetSection(oObjectPage, targetControlId);
+				return; // Required by linter rule promise/always-return
+			})
+			.catch(() => {
+				// applyAppState failed - skip targetControlId navigation
+			});
+	}
+
+	/**
+	 * Navigates to a target section with automatic re-navigation if UX rules reset the selection.
+	 * Polls the section state since setSelectedSection() doesn't fire the navigate event.
+	 * @param oObjectPage The ObjectPageLayout control.
+	 * @param targetControlId The local ID of the target section or subsection.
+	 */
+	private navigateToTargetSection(oObjectPage: ObjectPageLayout, targetControlId: string): void {
+		// Determine target section ID for comparison
+		const targetControl = this.getView().byId(targetControlId);
+		const isSection = targetControl?.isA("sap.uxap.ObjectPageSection");
+		const targetSectionId = isSection ? targetControl?.getId() : (targetControl?.getParent() as ObjectPageSection)?.getId();
+
+		// Navigate function with guard to prevent duplicate calls when already on target
+		const navigateToTarget = (): void => {
+			if (oObjectPage.getSelectedSection() === targetSectionId) {
+				return; // Already on target section
+			}
+			this.navigateWithConfirmation(targetControlId);
+		};
+
+		// Navigate immediately
+		navigateToTarget();
+
+		// Skip polling if already on target section (navigation was no-op or succeeded immediately)
+		if (oObjectPage.getSelectedSection() === targetSectionId) {
+			this.skipViewStateSectionRestore = true;
+			return;
+		}
+
+		// Poll to detect UX rules reset only on new entity binding.
+		// _adjustSelectedSectionByUXRules() only runs when ObjectPageLayout re-initializes with a new entity.
+		if (this.isNewBindingContext) {
+			pollForSectionStability({
+				getSelectedSection: () => oObjectPage.getSelectedSection(),
+				targetSectionId,
+				onResetDetected: navigateToTarget
+			})
+				.then(() => {
+					this.skipViewStateSectionRestore = true;
+					return; // Required by linter rule promise/always-return
+				})
+				.catch(() => {
+					// Required by linter rule promise/catch-or-return - polling failures are non-critical
+				});
+		}
+	}
+
+	/**
+	 * Sets targetSubSection based on the target control ID for app state persistence.
+	 * @param targetControlId The local ID of the target section or subsection.
+	 */
+	private setTargetSubSection(targetControlId: string): void {
+		const targetControl = this.getView().byId(targetControlId);
+		if (targetControl?.isA<ObjectPageSubSection>("sap.uxap.ObjectPageSubSection")) {
+			this.targetSubSection = targetControl;
+		} else if (targetControl?.isA<ObjectPageSection>("sap.uxap.ObjectPageSection")) {
+			const subSections = targetControl.getSubSections();
+			this.targetSubSection = subSections[0];
+		}
+	}
+
+	/**
+	 * Performs navigation to the target section and then updates the app state.
+	 * @param targetControlId The local ID of the target section or subsection.
+	 */
+	private navigateWithConfirmation(targetControlId: string): void {
+		// Set targetSubSection BEFORE navigation for app state saving.
+		// scrollToSection() doesn't fire the navigate event, so onNavigateChange won't be called.
+		this.setTargetSubSection(targetControlId);
+
+		this.getExtensionAPI().navigateToSubSection(targetControlId);
+
+		// Wait for ExtensionAPI polling to complete (~100ms) plus scroll to finish
+		// before updating app state and setting focus.
+		setTimeout(() => {
+			this.viewState.updateAppStateDebounced();
+
+			// Set focus if in edit mode (for in-app navigation to sub-object page in edit mode)
+			// This is needed because scrollToSection() doesn't fire onNavigateChange,
+			// so we need to manually trigger focus setting here
+			const isInEditMode = CommonUtils.getIsEditable(this.getView());
+			if (isInEditMode && this.targetSubSection) {
+				this._updateFocusInEditMode([this.targetSubSection], false);
+			}
+		}, 150);
 	}
 
 	/**
@@ -1384,9 +1582,7 @@ class ObjectPageController extends PageController {
 			// If there is at least one global SideEffects for the related entity, execute it/them
 			if (globalSideEffects.length) {
 				await this.editFlow.syncTask();
-				return Promise.all(
-					globalSideEffects.map(async (sideEffects) => this._sideEffects.requestSideEffects(sideEffects, context))
-				);
+				return Promise.all(globalSideEffects.map(async (sideEffects) => this.sideEffects.requestSideEffects(sideEffects, context)));
 			}
 		}
 
@@ -2204,17 +2400,25 @@ class ObjectPageController extends PageController {
 
 		onNavigateChange(this: ObjectPageController, oEvent: UI5Event<{ subSection: ObjectPageSubSection }>): void {
 			//will be called always when we click on a section tab
-			this.getExtensionAPI().updateAppState();
 			this.bSectionNavigated = true;
 
+			// Prevent ViewState from overriding the user's manual tab selection.
+			// This is important after discard when ViewState.apply might try to restore the previous section.
+			this.skipViewStateSectionRestore = true;
+
+			const subSection = oEvent.getParameter("subSection");
+			this.targetSubSection = subSection;
+
+			this.getExtensionAPI().updateAppState();
+
 			const oInternalModelContext = this.getView().getBindingContext("internal") as InternalModelContext;
+
 			if (
 				CommonUtils.getIsEditable(this.getView()) &&
 				this.getView().getViewData().sectionLayout === "Tabs" &&
 				oInternalModelContext.getProperty("errorNavigationSectionFlag") === false
 			) {
-				const oSubSection = oEvent.getParameter("subSection");
-				this._updateFocusInEditMode([oSubSection], true);
+				this._updateFocusInEditMode([subSection], true);
 			}
 		},
 		onVariantSelected: function (this: ObjectPageController): void {