@sapui5/sap.fe.templates 1.120.11 → 1.120.12

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sapui5/sap.fe.templates",
-	"version": "1.120.11",
+	"version": "1.120.12",
 	"description": "SAPUI5 Library sap.fe.templates",
 	"keywords": [
 		"sapui5",

package/src/sap/fe/templates/.library

@@ -6,7 +6,7 @@
 		SAP UI development toolkit for HTML5 (SAPUI5)
         (c) Copyright 2009-2021 SAP SE. All rights reserved
 	</copyright>
-	<version>1.120.11</version>
+	<version>1.120.12</version>
 
 	<documentation>UI5 library: sap.fe.templates</documentation>
 

package/src/sap/fe/templates/AnalyticalListPage/manifest.json

@@ -4,7 +4,7 @@
 		"id": "sap.fe.templates.AnalyticalListPage",
 		"type": "component",
 		"applicationVersion": {
-			"version": "1.120.11"
+			"version": "1.120.12"
 		},
 		"title": "Analytical List Page",
 		"tags": {

package/src/sap/fe/templates/ListReport/manifest.json

@@ -4,7 +4,7 @@
 		"id": "sap.fe.templates.ListReport",
 		"type": "component",
 		"applicationVersion": {
-			"version": "1.120.11"
+			"version": "1.120.12"
 		},
 		"title": "List Report",
 		"tags": {

package/src/sap/fe/templates/ObjectPage/manifest.json

@@ -4,7 +4,7 @@
 		"id": "sap.fe.templates.ObjectPage",
 		"type": "component",
 		"applicationVersion": {
-			"version": "1.120.11"
+			"version": "1.120.12"
 		},
 		"title": "Object Page",
 		"tags": {

package/src/sap/fe/templates/ObjectPage/overrides/ViewState.js

@@ -2,11 +2,128 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2023 SAP SE. All rights reserved
  */
-sap.ui.define(["sap/fe/core/helpers/KeepAliveHelper", "sap/fe/core/library"], function (KeepAliveHelper, CoreLibrary) {
+sap.ui.define(["sap/base/Log", "sap/fe/core/CommonUtils", "sap/fe/core/helpers/KeepAliveHelper", "sap/fe/core/helpers/ModelHelper", "sap/fe/core/library"], function (Log, CommonUtils, KeepAliveHelper, ModelHelper, CoreLibrary) {
   "use strict";
 
   const VariantManagement = CoreLibrary.VariantManagement;
+  const opControlHandlers = {
+    retrieve: function (oOPLayout) {
+      return {
+        selectedSection: oOPLayout.getSelectedSection()
+      };
+    },
+    apply: function (opLayout, controlState) {
+      const selectedSection = controlState === null || controlState === void 0 ? void 0 : controlState.selectedSection;
+      if (selectedSection) {
+        const opSectionToSelect = opLayout.getSections().find(section => section.getId() === selectedSection);
+        if ((opSectionToSelect === null || opSectionToSelect === void 0 ? void 0 : opSectionToSelect.getVisible()) === false) {
+          const controller = this.getView().getController();
+          controller.pageReady.waitPageReady().then(function () {
+            opLayout.setSelectedSection(selectedSection);
+            return undefined;
+          }).catch(err => {
+            const message = err instanceof Error ? err.message : String(err);
+            Log.error(`FE V4 : OP : ViewState : ObjectPageLayout state couldn't be applied : ${message}`);
+          });
+        } else {
+          opLayout.setSelectedSection(selectedSection);
+        }
+      }
+    },
+    refreshBinding: function (oOPLayout) {
+      const oBindingContext = oOPLayout.getBindingContext();
+      if (oBindingContext !== null && oBindingContext !== void 0 && oBindingContext.getBinding()) {
+        const oBinding = oBindingContext.getBinding();
+        const sMetaPath = ModelHelper.getMetaPathForContext(oBindingContext);
+        const sStrategy = KeepAliveHelper.getControlRefreshStrategyForContextPath(oOPLayout, sMetaPath);
+        if (sStrategy === "self") {
+          // Refresh main context and 1-1 navigation properties or OP
+          const oModel = oBindingContext.getModel(),
+            oMetaModel = oModel.getMetaModel(),
+            oNavigationProperties = CommonUtils.getContextPathProperties(oMetaModel, sMetaPath, {
+              $kind: "NavigationProperty"
+            }) || {},
+            aNavPropertiesToRequest = Object.keys(oNavigationProperties).reduce(function (aPrev, sNavProp) {
+              if (oNavigationProperties[sNavProp].$isCollection !== true) {
+                aPrev.push({
+                  $NavigationPropertyPath: sNavProp
+                });
+              }
+              return aPrev;
+            }, []),
+            aProperties = [{
+              $PropertyPath: "*"
+            }],
+            sGroupId = oBinding.getGroupId();
+          oBindingContext.requestSideEffects(aProperties.concat(aNavPropertiesToRequest), sGroupId);
+        } else if (sStrategy === "includingDependents") {
+          // Complete refresh
+          oBinding.refresh();
+        }
+      } else {
+        Log.info(`ObjectPage: ${oOPLayout.getId()} was not refreshed. No binding found!`);
+      }
+    }
+  };
   const ViewStateExtensionOverride = {
+    _getObjectPageLayout: function () {
+      const view = this.getView();
+      const controller = view.getController();
+      return controller._getObjectPageLayoutControl();
+    },
+    /**
+     * Get the state handler for ObjectPageLayout in view.
+     *
+     * @param control The control for state interaction
+     * @returns State handler
+     */
+    _getOPStateHandler: function (control) {
+      const viewOP = ViewStateExtensionOverride._getObjectPageLayout.call(this);
+      if (viewOP === control) {
+        return {
+          retrieve: opControlHandlers.retrieve,
+          apply: opControlHandlers.apply
+        };
+      }
+    },
+    /**
+     * Get the refresh handler for ObjectPageLayout in view.
+     *
+     * @param control The control being refreshed
+     * @returns Refresh handler
+     */
+    _getOPRefreshHandler: function (control) {
+      const viewOP = ViewStateExtensionOverride._getObjectPageLayout.call(this);
+      if (viewOP === control) {
+        return {
+          refreshBinding: opControlHandlers.refreshBinding
+        };
+      }
+    },
+    /**
+     * Pass the state handlers of object page view according to the control in concern.
+     *
+     * @param control The control for state interaction
+     * @param controlStateHandlers State handlers
+     */
+    adaptControlStateHandler: function (control, controlStateHandlers) {
+      const opStateHandler = ViewStateExtensionOverride._getOPStateHandler.call(this, control);
+      if (opStateHandler) {
+        controlStateHandlers.push(opStateHandler);
+      }
+    },
+    /**
+     * Pass the refresh handlers of object page view according to the control being refreshed.
+     *
+     * @param control The control being refreshed
+     * @param controlRefreshHandlers Refresh handlers
+     */
+    adaptBindingRefreshHandler: function (control, controlRefreshHandlers) {
+      const opStateHandler = ViewStateExtensionOverride._getOPRefreshHandler.call(this, control);
+      if (opStateHandler) {
+        controlRefreshHandlers.push(opStateHandler);
+      }
+    },
     applyInitialStateOnly: function () {
       return false;
     },
@@ -66,4 +183,4 @@ sap.ui.define(["sap/fe/core/helpers/KeepAliveHelper", "sap/fe/core/library"], fu
   };
   return ViewStateExtensionOverride;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["VariantManagement","CoreLibrary","opControlHandlers","retrieve","oOPLayout","selectedSection","getSelectedSection","apply","opLayout","controlState","opSectionToSelect","getSections","find","section","getId","getVisible","controller","getView","getController","pageReady","waitPageReady","then","setSelectedSection","undefined","catch","err","message","Error","String","Log","error","refreshBinding","oBindingContext","getBindingContext","getBinding","oBinding","sMetaPath","ModelHelper","getMetaPathForContext","sStrategy","KeepAliveHelper","getControlRefreshStrategyForContextPath","oModel","getModel","oMetaModel","getMetaModel","oNavigationProperties","CommonUtils","getContextPathProperties","$kind","aNavPropertiesToRequest","Object","keys","reduce","aPrev","sNavProp","$isCollection","push","$NavigationPropertyPath","aProperties","$PropertyPath","sGroupId","getGroupId","requestSideEffects","concat","refresh","info","ViewStateExtensionOverride","_getObjectPageLayout","view","_getObjectPageLayoutControl","_getOPStateHandler","control","viewOP","call","_getOPRefreshHandler","adaptControlStateHandler","controlStateHandlers","opStateHandler","adaptBindingRefreshHandler","controlRefreshHandlers","applyInitialStateOnly","adaptStateControls","aStateControls","oView","oController","oViewData","getViewData","bControlVM","variantManagement","Control","Page","None","getVariantManagement","_findTables","forEach","oTable","oQuickFilter","getQuickFilter","getVariant","_findCharts","oChart","byId","adaptBindingRefreshControls","aControls","base","sRefreshStrategy","getViewRefreshInfo","aControlsToRefresh","oObjectPageControl","aViewControls","getControlsForRefresh","aPrevControls","oControl","indexOf"],"sourceRoot":".","sources":["ViewState.ts"],"sourcesContent":["import Log from \"sap/base/Log\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport type ViewState from \"sap/fe/core/controllerextensions/ViewState\";\nimport { type ControlStateHandler } from \"sap/fe/core/controllerextensions/ViewState\";\nimport KeepAliveHelper from \"sap/fe/core/helpers/KeepAliveHelper\";\nimport ModelHelper from \"sap/fe/core/helpers/ModelHelper\";\nimport CoreLibrary from \"sap/fe/core/library\";\nimport type ObjectPageController from \"sap/fe/templates/ObjectPage/ObjectPageController.controller\";\nimport type ManagedObject from \"sap/ui/base/ManagedObject\";\nimport type Control from \"sap/ui/core/Control\";\nimport type Context from \"sap/ui/model/odata/v4/Context\";\nimport type ObjectPageLayout from \"sap/uxap/ObjectPageLayout\";\nimport type ObjectPageSection from \"sap/uxap/ObjectPageSection\";\nimport type { MetaModelNavProperty } from \"types/metamodel_types\";\n\nconst VariantManagement = CoreLibrary.VariantManagement;\nexport type ObjectPageState = { selectedSection: string | null };\n\nconst opControlHandlers = {\n\tretrieve: function (oOPLayout: ObjectPageLayout): ObjectPageState {\n\t\treturn {\n\t\t\tselectedSection: oOPLayout.getSelectedSection()\n\t\t};\n\t},\n\tapply: function (this: ViewState, opLayout: ObjectPageLayout, controlState?: { selectedSection: string | null }): void {\n\t\tconst selectedSection = controlState?.selectedSection;\n\t\tif (selectedSection) {\n\t\t\tconst opSectionToSelect = opLayout.getSections().find((section: ObjectPageSection) => section.getId() === selectedSection);\n\t\t\tif (opSectionToSelect?.getVisible() === false) {\n\t\t\t\tconst controller = this.getView().getController() as ObjectPageController;\n\t\t\t\tcontroller.pageReady\n\t\t\t\t\t.waitPageReady()\n\t\t\t\t\t.then(function (): void {\n\t\t\t\t\t\topLayout.setSelectedSection(selectedSection);\n\t\t\t\t\t\treturn undefined;\n\t\t\t\t\t})\n\t\t\t\t\t.catch((err: unknown): void => {\n\t\t\t\t\t\tconst message = err instanceof Error ? err.message : String(err);\n\t\t\t\t\t\tLog.error(`FE V4 : OP : ViewState : ObjectPageLayout state couldn't be applied : ${message}`);\n\t\t\t\t\t});\n\t\t\t} else {\n\t\t\t\topLayout.setSelectedSection(selectedSection);\n\t\t\t}\n\t\t}\n\t},\n\trefreshBinding: function (oOPLayout: ObjectPageLayout): void {\n\t\tconst oBindingContext = oOPLayout.getBindingContext() as Context | undefined;\n\t\tif (oBindingContext?.getBinding()) {\n\t\t\tconst oBinding = oBindingContext.getBinding();\n\t\t\tconst sMetaPath = ModelHelper.getMetaPathForContext(oBindingContext);\n\t\t\tconst sStrategy = KeepAliveHelper.getControlRefreshStrategyForContextPath(oOPLayout, sMetaPath);\n\t\t\tif (sStrategy === \"self\") {\n\t\t\t\t// Refresh main context and 1-1 navigation properties or OP\n\t\t\t\tconst oModel = oBindingContext.getModel(),\n\t\t\t\t\toMetaModel = oModel.getMetaModel(),\n\t\t\t\t\toNavigationProperties: Record<string, MetaModelNavProperty> =\n\t\t\t\t\t\t(CommonUtils.getContextPathProperties(oMetaModel, sMetaPath, {\n\t\t\t\t\t\t\t$kind: \"NavigationProperty\"\n\t\t\t\t\t\t}) as Record<string, MetaModelNavProperty>) || {},\n\t\t\t\t\taNavPropertiesToRequest = Object.keys(oNavigationProperties).reduce(function (\n\t\t\t\t\t\taPrev: { $NavigationPropertyPath: string }[],\n\t\t\t\t\t\tsNavProp: string\n\t\t\t\t\t) {\n\t\t\t\t\t\tif (oNavigationProperties[sNavProp].$isCollection !== true) {\n\t\t\t\t\t\t\taPrev.push({ $NavigationPropertyPath: sNavProp });\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn aPrev;\n\t\t\t\t\t}, []),\n\t\t\t\t\taProperties: ({ $NavigationPropertyPath: string } | { $PropertyPath: string })[] = [{ $PropertyPath: \"*\" }],\n\t\t\t\t\tsGroupId = oBinding.getGroupId();\n\n\t\t\t\toBindingContext.requestSideEffects(aProperties.concat(aNavPropertiesToRequest), sGroupId);\n\t\t\t} else if (sStrategy === \"includingDependents\") {\n\t\t\t\t// Complete refresh\n\t\t\t\toBinding.refresh();\n\t\t\t}\n\t\t} else {\n\t\t\tLog.info(`ObjectPage: ${oOPLayout.getId()} was not refreshed. No binding found!`);\n\t\t}\n\t}\n};\n\nconst ViewStateExtensionOverride = {\n\t_getObjectPageLayout: function (this: ViewState): ObjectPageLayout {\n\t\tconst view = this.getView();\n\t\tconst controller = view.getController() as ObjectPageController;\n\t\treturn controller._getObjectPageLayoutControl();\n\t},\n\n\t/**\n\t * Get the state handler for ObjectPageLayout in view.\n\t *\n\t * @param control The control for state interaction\n\t * @returns State handler\n\t */\n\t_getOPStateHandler: function (\n\t\tthis: ViewState,\n\t\tcontrol: ManagedObject\n\t): ControlStateHandler<ObjectPageLayout, ObjectPageState> | undefined {\n\t\tconst viewOP = ViewStateExtensionOverride._getObjectPageLayout.call(this);\n\t\tif (viewOP === control) {\n\t\t\treturn {\n\t\t\t\tretrieve: opControlHandlers.retrieve,\n\t\t\t\tapply: opControlHandlers.apply\n\t\t\t};\n\t\t}\n\t},\n\n\t/**\n\t * Get the refresh handler for ObjectPageLayout in view.\n\t *\n\t * @param control The control being refreshed\n\t * @returns Refresh handler\n\t */\n\t_getOPRefreshHandler: function (\n\t\tthis: ViewState,\n\t\tcontrol: ManagedObject\n\t): ControlStateHandler<ObjectPageLayout, ObjectPageState> | undefined {\n\t\tconst viewOP = ViewStateExtensionOverride._getObjectPageLayout.call(this);\n\t\tif (viewOP === control) {\n\t\t\treturn {\n\t\t\t\trefreshBinding: opControlHandlers.refreshBinding\n\t\t\t};\n\t\t}\n\t},\n\n\t/**\n\t * Pass the state handlers of object page view according to the control in concern.\n\t *\n\t * @param control The control for state interaction\n\t * @param controlStateHandlers State handlers\n\t */\n\tadaptControlStateHandler: function (\n\t\tthis: ViewState,\n\t\tcontrol: ManagedObject,\n\t\tcontrolStateHandlers: ControlStateHandler<ObjectPageLayout, ObjectPageState>[]\n\t): void {\n\t\tconst opStateHandler = ViewStateExtensionOverride._getOPStateHandler.call(this, control);\n\t\tif (opStateHandler) {\n\t\t\tcontrolStateHandlers.push(opStateHandler);\n\t\t}\n\t},\n\n\t/**\n\t * Pass the refresh handlers of object page view according to the control being refreshed.\n\t *\n\t * @param control The control being refreshed\n\t * @param controlRefreshHandlers Refresh handlers\n\t */\n\tadaptBindingRefreshHandler: function (\n\t\tthis: ViewState,\n\t\tcontrol: ManagedObject,\n\t\tcontrolRefreshHandlers: ControlStateHandler<ObjectPageLayout, ObjectPageState>[]\n\t): void {\n\t\tconst opStateHandler = ViewStateExtensionOverride._getOPRefreshHandler.call(this, control);\n\t\tif (opStateHandler) {\n\t\t\tcontrolRefreshHandlers.push(opStateHandler);\n\t\t}\n\t},\n\n\tapplyInitialStateOnly: function (): boolean {\n\t\treturn false;\n\t},\n\tadaptStateControls: function (this: ViewState, aStateControls: any) {\n\t\tconst oView = this.getView(),\n\t\t\toController = oView.getController(),\n\t\t\toViewData = oView.getViewData() as any;\n\t\tlet bControlVM = false;\n\n\t\tswitch (oViewData.variantManagement) {\n\t\t\tcase VariantManagement.Control:\n\t\t\t\tbControlVM = true;\n\t\t\t\tbreak;\n\t\t\tcase VariantManagement.Page:\n\t\t\tcase VariantManagement.None:\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthrow new Error(`unhandled variant setting: ${oViewData.getVariantManagement()}`);\n\t\t}\n\n\t\t(oController as ObjectPageController)._findTables().forEach(function (oTable: any) {\n\t\t\tconst oQuickFilter = oTable.getQuickFilter();\n\t\t\tif (oQuickFilter) {\n\t\t\t\taStateControls.push(oQuickFilter);\n\t\t\t}\n\t\t\tif (bControlVM) {\n\t\t\t\taStateControls.push(oTable.getVariant());\n\t\t\t}\n\t\t\taStateControls.push(oTable);\n\t\t});\n\n\t\t(oController as ObjectPageController)._findCharts().forEach(function (oChart: any) {\n\t\t\tif (bControlVM) {\n\t\t\t\taStateControls.push(oChart.getVariant());\n\t\t\t}\n\t\t\taStateControls.push(oChart);\n\t\t});\n\n\t\taStateControls.push(oView.byId(\"fe::ObjectPage\"));\n\t},\n\tadaptBindingRefreshControls: function (this: ViewState, aControls: any) {\n\t\tconst oView = this.base.getView(),\n\t\t\tsRefreshStrategy = KeepAliveHelper.getViewRefreshInfo(oView),\n\t\t\toController = oView.getController();\n\t\tlet aControlsToRefresh: Control[] = [];\n\n\t\tif (sRefreshStrategy) {\n\t\t\tconst oObjectPageControl = (oController as ObjectPageController)._getObjectPageLayoutControl();\n\t\t\taControlsToRefresh.push(oObjectPageControl);\n\t\t}\n\t\tif (sRefreshStrategy !== \"includingDependents\") {\n\t\t\tconst aViewControls = (oController as ObjectPageController)._findTables();\n\t\t\taControlsToRefresh = aControlsToRefresh.concat(KeepAliveHelper.getControlsForRefresh(oView, aViewControls) || []);\n\t\t}\n\t\treturn aControlsToRefresh.reduce(function (aPrevControls: any, oControl: any) {\n\t\t\tif (aPrevControls.indexOf(oControl) === -1) {\n\t\t\t\taPrevControls.push(oControl);\n\t\t\t}\n\t\t\treturn aPrevControls;\n\t\t}, aControls);\n\t}\n};\n\nexport default ViewStateExtensionOverride;\n"],"mappings":"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"}

package/src/sap/fe/templates/ObjectPage/overrides/ViewState.ts

@@ -1,13 +1,164 @@
+import Log from "sap/base/Log";
+import CommonUtils from "sap/fe/core/CommonUtils";
 import type ViewState from "sap/fe/core/controllerextensions/ViewState";
+import { type ControlStateHandler } from "sap/fe/core/controllerextensions/ViewState";
 import KeepAliveHelper from "sap/fe/core/helpers/KeepAliveHelper";
+import ModelHelper from "sap/fe/core/helpers/ModelHelper";
 import CoreLibrary from "sap/fe/core/library";
 import type ObjectPageController from "sap/fe/templates/ObjectPage/ObjectPageController.controller";
+import type ManagedObject from "sap/ui/base/ManagedObject";
 import type Control from "sap/ui/core/Control";
+import type Context from "sap/ui/model/odata/v4/Context";
+import type ObjectPageLayout from "sap/uxap/ObjectPageLayout";
+import type ObjectPageSection from "sap/uxap/ObjectPageSection";
+import type { MetaModelNavProperty } from "types/metamodel_types";
 
 const VariantManagement = CoreLibrary.VariantManagement;
+export type ObjectPageState = { selectedSection: string | null };
+
+const opControlHandlers = {
+	retrieve: function (oOPLayout: ObjectPageLayout): ObjectPageState {
+		return {
+			selectedSection: oOPLayout.getSelectedSection()
+		};
+	},
+	apply: function (this: ViewState, opLayout: ObjectPageLayout, controlState?: { selectedSection: string | null }): void {
+		const selectedSection = controlState?.selectedSection;
+		if (selectedSection) {
+			const opSectionToSelect = opLayout.getSections().find((section: ObjectPageSection) => section.getId() === selectedSection);
+			if (opSectionToSelect?.getVisible() === false) {
+				const controller = this.getView().getController() as ObjectPageController;
+				controller.pageReady
+					.waitPageReady()
+					.then(function (): void {
+						opLayout.setSelectedSection(selectedSection);
+						return undefined;
+					})
+					.catch((err: unknown): void => {
+						const message = err instanceof Error ? err.message : String(err);
+						Log.error(`FE V4 : OP : ViewState : ObjectPageLayout state couldn't be applied : ${message}`);
+					});
+			} else {
+				opLayout.setSelectedSection(selectedSection);
+			}
+		}
+	},
+	refreshBinding: function (oOPLayout: ObjectPageLayout): void {
+		const oBindingContext = oOPLayout.getBindingContext() as Context | undefined;
+		if (oBindingContext?.getBinding()) {
+			const oBinding = oBindingContext.getBinding();
+			const sMetaPath = ModelHelper.getMetaPathForContext(oBindingContext);
+			const sStrategy = KeepAliveHelper.getControlRefreshStrategyForContextPath(oOPLayout, sMetaPath);
+			if (sStrategy === "self") {
+				// Refresh main context and 1-1 navigation properties or OP
+				const oModel = oBindingContext.getModel(),
+					oMetaModel = oModel.getMetaModel(),
+					oNavigationProperties: Record<string, MetaModelNavProperty> =
+						(CommonUtils.getContextPathProperties(oMetaModel, sMetaPath, {
+							$kind: "NavigationProperty"
+						}) as Record<string, MetaModelNavProperty>) || {},
+					aNavPropertiesToRequest = Object.keys(oNavigationProperties).reduce(function (
+						aPrev: { $NavigationPropertyPath: string }[],
+						sNavProp: string
+					) {
+						if (oNavigationProperties[sNavProp].$isCollection !== true) {
+							aPrev.push({ $NavigationPropertyPath: sNavProp });
+						}
+						return aPrev;
+					}, []),
+					aProperties: ({ $NavigationPropertyPath: string } | { $PropertyPath: string })[] = [{ $PropertyPath: "*" }],
+					sGroupId = oBinding.getGroupId();
+
+				oBindingContext.requestSideEffects(aProperties.concat(aNavPropertiesToRequest), sGroupId);
+			} else if (sStrategy === "includingDependents") {
+				// Complete refresh
+				oBinding.refresh();
+			}
+		} else {
+			Log.info(`ObjectPage: ${oOPLayout.getId()} was not refreshed. No binding found!`);
+		}
+	}
+};
 
 const ViewStateExtensionOverride = {
-	applyInitialStateOnly: function () {
+	_getObjectPageLayout: function (this: ViewState): ObjectPageLayout {
+		const view = this.getView();
+		const controller = view.getController() as ObjectPageController;
+		return controller._getObjectPageLayoutControl();
+	},
+
+	/**
+	 * Get the state handler for ObjectPageLayout in view.
+	 *
+	 * @param control The control for state interaction
+	 * @returns State handler
+	 */
+	_getOPStateHandler: function (
+		this: ViewState,
+		control: ManagedObject
+	): ControlStateHandler<ObjectPageLayout, ObjectPageState> | undefined {
+		const viewOP = ViewStateExtensionOverride._getObjectPageLayout.call(this);
+		if (viewOP === control) {
+			return {
+				retrieve: opControlHandlers.retrieve,
+				apply: opControlHandlers.apply
+			};
+		}
+	},
+
+	/**
+	 * Get the refresh handler for ObjectPageLayout in view.
+	 *
+	 * @param control The control being refreshed
+	 * @returns Refresh handler
+	 */
+	_getOPRefreshHandler: function (
+		this: ViewState,
+		control: ManagedObject
+	): ControlStateHandler<ObjectPageLayout, ObjectPageState> | undefined {
+		const viewOP = ViewStateExtensionOverride._getObjectPageLayout.call(this);
+		if (viewOP === control) {
+			return {
+				refreshBinding: opControlHandlers.refreshBinding
+			};
+		}
+	},
+
+	/**
+	 * Pass the state handlers of object page view according to the control in concern.
+	 *
+	 * @param control The control for state interaction
+	 * @param controlStateHandlers State handlers
+	 */
+	adaptControlStateHandler: function (
+		this: ViewState,
+		control: ManagedObject,
+		controlStateHandlers: ControlStateHandler<ObjectPageLayout, ObjectPageState>[]
+	): void {
+		const opStateHandler = ViewStateExtensionOverride._getOPStateHandler.call(this, control);
+		if (opStateHandler) {
+			controlStateHandlers.push(opStateHandler);
+		}
+	},
+
+	/**
+	 * Pass the refresh handlers of object page view according to the control being refreshed.
+	 *
+	 * @param control The control being refreshed
+	 * @param controlRefreshHandlers Refresh handlers
+	 */
+	adaptBindingRefreshHandler: function (
+		this: ViewState,
+		control: ManagedObject,
+		controlRefreshHandlers: ControlStateHandler<ObjectPageLayout, ObjectPageState>[]
+	): void {
+		const opStateHandler = ViewStateExtensionOverride._getOPRefreshHandler.call(this, control);
+		if (opStateHandler) {
+			controlRefreshHandlers.push(opStateHandler);
+		}
+	},
+
+	applyInitialStateOnly: function (): boolean {
 		return false;
 	},
 	adaptStateControls: function (this: ViewState, aStateControls: any) {

package/src/sap/fe/templates/library.js

@@ -36,7 +36,7 @@ sap.ui.define(["sap/f/library", "sap/fe/core/library", "sap/fe/macros/library",
     controls: [],
     elements: [],
     // eslint-disable-next-line no-template-curly-in-string
-    version: "1.120.11",
+    version: "1.120.12",
     noLibraryCSS: true
   });
   if (!thisLib.ObjectPage) {