@sapui5/sap.suite.ui.generic.template 1.145.0 → 1.145.2

package/src/sap/suite/ui/generic/template/genericUtilities/controlStateWrapperFactory/SmartTableChartCommon.js

@@ -4,41 +4,64 @@ sap.ui.define([
 
     /**
      * Constructor for SmartTableChartCommon
-     * ...
-     * @param {object} mParams
-     * @param mParams.oCustomFiltersWrapper - wrapper for custom filters (from SFB point of view)
-     *   (currently containing: generic (currently only editState), app extension, and adaptation extension - but this is knowledge of LR, i.e. of iAppStateHandler, not of SFB)
+     * @param {sap.ui.core.Control} oControl - The SmartTable or SmartChart control
+     * @param {object} oController - The controller instance
+     * @param {object} oFactory - The ControlStateWrapperFactory instance
+     * @param {string} sInitializationEvent - The initialization event name (e.g., "initialise")
+     * @param {object} [mExtensions] - Optional extension functions for control-specific state handling
+     * @param {function} [mExtensions.fnExtendGetUiState] - Function to extend UiState during getState
+     *   Called with (oStateUiState, oControlUiState) where modifications to oStateUiState add to the state
+     * @param {function} [mExtensions.fnExtendSetUiState] - Function to extend UiState during setState
+     *   Called with (oStateUiState, oControlUiState) where oStateUiState contains the state to apply
      * @returns {object}
      */
 
     // deals with state of SFB itself, without SVM (see SmartVariantManagementWrapper) and go-button
     // (does not contain a state from SFB point of view - however, we remember whether it was pressed once
     // to restore data - this information is not considered being part of SFB)
-    function SmartTableChartCommon(vTarget, oController, oFactory, sInitializationEvent) {
-        var oSmartControl, oVariantManagementControl, bVariantManagementActive;
-        var oControlAssignedResolve, oPreliminaryState, bSmartControlInitialized;
+    function SmartTableChartCommon(oControl, oController, oFactory, sInitializationEvent, mExtensions) {
+        var oSmartControl = oControl;
+        var oVariantManagementControl, bVariantManagementActive;
         var oSmartControlStateWrapper;
         var oVariantManagementStateWrapper;
+        var oVariantManagementInitializedResolve;
+        var fnResolveReady;
 
-        var oControlAssignedPromise = new Promise(function (resolve) {
-            oControlAssignedResolve = resolve;
+        var oVariantManagementInitializedPromise = new Promise(function(resolve){
+            oVariantManagementInitializedResolve = resolve;
         });
 
-        if (typeof vTarget !== "string") {
-            fnSetControl(vTarget);
+        var oReadyPromise = new Promise(function(resolve) {
+            fnResolveReady = resolve;
+        });
+
+        // Initialize control state wrapper and check if control is already initialized
+        oSmartControlStateWrapper = getControlWrapper(oSmartControl);
+        if (!oSmartControl.isInitialised()) {
+            // In case Smart Chart/Table is not yet initialized
+            // listen to the initialize event & then initialize the wrapper
+            oSmartControl.attachEvent(sInitializationEvent, fnControlInitialized);
+        } else {
+            fnControlInitialized();
         }
 
         // creates a simple wrapper for a SmartTable or SmartChart (a control using UIState) (ignoring initialization and vm)
         function getControlWrapper(oControl) {
             var bIsApplying = false;		// avoid forwarding change event when caused by us applying a state
             function fnGetState() {
-                var oUiState = oControl.getUiState(); // unfortunately not serializable, but a managed object
+                var oControlUiState = oControl.getUiState(); // unfortunately not serializable, but a managed object
+                var oStateUiState = {
+                    oPresentationVariant: oControlUiState.getPresentationVariant(),
+                    oSelectionVariant: oControlUiState.getSelectionVariant()
+                };
+
+                // Allow extension to add control-specific properties (e.g., tableSettings for SmartTable)
+                if (mExtensions && mExtensions.fnExtendGetUiState) {
+                    mExtensions.fnExtendGetUiState(oStateUiState, oControlUiState);
+                }
+
                 return {
-                    oUiState: {
-                        oPresentationVariant: oUiState.getPresentationVariant(),
-                        oSelectionVariant: oUiState.getSelectionVariant(),
-                        oTableSettings: oUiState.getTableSettings()
-                    }
+                    oUiState: oStateUiState
                 };
             }
 
@@ -53,15 +76,20 @@ sap.ui.define([
                     bIsApplying = true;
                     // don't create UiState (managed object) from scratch, but fetch it from control and only apply known properties from state - thus, if any other properties would be added, we don't
                     // interfere with them
-                    var oUiState = oControl.getUiState();
+                    var oControlUiState = oControl.getUiState();
                     if (
-                        oUiState.getProperty("variantName") === "" || 
-                        oControl.getVariantManagement().getModified() && oControl.getVariantManagement().getStandardVariantKey() === oUiState.getProperty("variantName")
+                        oControlUiState.getProperty("variantName") === "" ||
+                        oControl.getVariantManagement().getModified() && oControl.getVariantManagement().getStandardVariantKey() === oControlUiState.getProperty("variantName")
                     ){
-                        oUiState.setPresentationVariant(oState.oUiState.oPresentationVariant);
-                        oUiState.setSelectionVariant(oState.oUiState.oSelectionVariant);
-                        oUiState.setTableSettings(oState.oUiState.oTableSettings);
-                        oControl.setUiState(oUiState);
+                            oControlUiState.setPresentationVariant(oState.oUiState.oPresentationVariant);
+                            oControlUiState.setSelectionVariant(oState.oUiState.oSelectionVariant);
+
+                            // Allow extension to set control-specific properties (e.g., tableSettings for SmartTable)
+                            if (mExtensions && mExtensions.fnExtendSetUiState) {
+                                mExtensions.fnExtendSetUiState(oState.oUiState, oControlUiState);
+                            }
+
+                            oControl.setUiState(oControlUiState);
                     }
                     bIsApplying = false;
                 } else {
@@ -88,76 +116,58 @@ sap.ui.define([
                 setState: fnSetState,
                 getLocalId: fnGetLocalId,
                 bVMConnection: oControl && oControl.getSmartVariant && !!oControl.getSmartVariant(),
-                attachStateChanged: fnAttachStateChanged
+                attachStateChanged: fnAttachStateChanged,
+                onAfterVariantInitialise: oVariantManagementInitializedResolve
             };
         }
 
         function fnGetState() {
-            if (bSmartControlInitialized) {
-                if (oVariantManagementStateWrapper) {
-                    // oVariantManagementStateWrapper would be undefined only in cases SmartControl is not yet initialized
-                    // or VariantManagement is not enabled.
-                    return oVariantManagementStateWrapper.getState();
-                }
-
-                if (oSmartControlStateWrapper && !bVariantManagementActive) {
-                    // VariantManagement is not turned on & SmartControlStateWrapper instance
-                    return oSmartControlStateWrapper.getState();
-                }
+            if (oVariantManagementStateWrapper) {
+                // Variant management is active
+                return oVariantManagementStateWrapper.getState();
             }
 
-            // Control is not available and StateWrapper is not initialized
-            return oPreliminaryState;
+            // No variant management - return control state directly
+            return oSmartControlStateWrapper.getState();
         }
 
         function fnSetState(oState) {
-            oPreliminaryState = oState;
-            oControlAssignedPromise.then(function () {
-                // map legacy states - before separating VM state from state of managed control, inner state information
-                // (presentation variant and selection variant) were put as oUiState on the same level as VM state
-                // information (variant id and dirty indicator), now they are contained in map managedControlStates
-                if (oState){
-                    if (oState.oUiState && !oState.managedControlStates) {
-                        oState.managedControlStates = Object.create(null);
-                        oState.managedControlStates[oSmartControlStateWrapper.getLocalId()] = {oUiState: oState.oUiState};
-                    }
-                    if (oState.bVariantModified !== undefined) {
-                        oState.modified = oState.bVariantModified;
-                    }
-                    if (oState.sVariantId !== undefined) {
-                      oState.variantId = oState.sVariantId;
-                    }
-                }
-
+            if (!oState) {
+                // If no state provided, set standard variant on control
                 if (bVariantManagementActive) {
-                    // In case VariantManagement is configured
-                    oVariantManagementStateWrapper.setState(oPreliminaryState);
-                    return;
+                    oVariantManagementStateWrapper.setState(oState);
+                } else {
+                    oSmartControlStateWrapper.setState(oState);
                 }
-
-                // SmartTable/Chart shall be used
-                oSmartControlStateWrapper.setState(oPreliminaryState);
-            });
-        }
-
-        function fnSetControl(oControl) {
-            oSmartControl = oControl;
-            oSmartControlStateWrapper = getControlWrapper(oSmartControl);
-            if (!oSmartControl.isInitialised()) {
-                // In case Smart Chart/Table is not yet initialized
-                // listen to the initialize event & then resolve the control
-                oSmartControl.attachEvent(sInitializationEvent, fnControlInitialized);
                 return;
             }
 
-            fnControlInitialized();
+            // Map legacy states - before separating VM state from state of managed control, inner state information
+            // (presentation variant and selection variant) were put as oUiState on the same level as VM state
+            // information (variant id and dirty indicator), now they are contained in map managedControlStates
+            if (oState.oUiState && !oState.managedControlStates) {
+                oState.managedControlStates = Object.create(null);
+                oState.managedControlStates[oSmartControlStateWrapper.getLocalId()] = {oUiState: oState.oUiState};
+            }
+            if (oState.bVariantModified !== undefined) {
+                oState.modified = oState.bVariantModified;
+            }
+            if (oState.sVariantId !== undefined) {
+                oState.variantId = oState.sVariantId;
+            }
+
+            if (bVariantManagementActive) {
+                // In case VariantManagement is configured
+                oVariantManagementStateWrapper.setState(oState);
+            } else {
+                // SmartTable/Chart shall be used
+                oSmartControlStateWrapper.setState(oState);
+            }
         }
 
         function fnControlInitialized() {
-            bSmartControlInitialized = true;
-
             // deal with VM
-            // 3 possibilties with respect to VM
+            // 3 possibilities with respect to VM
             // a) no VM (relevant for this control) at all
             // b) control managed as part of page wide variant management
             // c) control creates own VM
@@ -181,39 +191,35 @@ sap.ui.define([
                     oVariantManagementStateWrapper = oFactory.getControlStateWrapper(oVariantManagementControl, {
                         managedControlWrappers: [ oSmartControlStateWrapper ]
                     });
-                    oControlAssignedResolve();
+                    fnResolveReady();
                 } else {
-                    // Resolve the ControlAssignedPromise only once the VariantManagement is
-                    // also initialized
+                    // Wait for VariantManagement to be initialized
                     oSmartControl.attachAfterVariantInitialise(fnControlInitialized);
                 }
-
-                return;
+            } else {
+                // No variant management or page-level variant management - ready immediately
+                fnResolveReady();
             }
-            // There is no VariantManagement configured for this SmartChart/SmartTable
-            oControlAssignedResolve(oSmartControl);
         }
 
         function fnAttachStateChanged(fnHandler) {
-            oControlAssignedPromise.then(function () {
-                if (bVariantManagementActive) {
-                    oVariantManagementStateWrapper.attachStateChanged(fnHandler);
-                    return;
-                }
-
+            if (bVariantManagementActive) {
+                oVariantManagementStateWrapper.attachStateChanged(fnHandler);
+            } else {
                 oSmartControlStateWrapper.attachStateChanged(fnHandler);
-
-            });
+            }
         }
 
         return {
             getState: fnGetState,
             setState: fnSetState,
-            setControl: fnSetControl,
             attachStateChanged: fnAttachStateChanged,
-            bVMConnection: oSmartControl && oSmartControl.getSmartVariant && !!oSmartControl.getSmartVariant()
+            bVMConnection: oSmartControl && oSmartControl.getSmartVariant && !!oSmartControl.getSmartVariant(),
+            oVariantManagementInitializedPromise: oVariantManagementInitializedPromise,
+            onAfterVariantInitialise: oVariantManagementInitializedResolve,
+            oReadyPromise: oReadyPromise
         };
     }
 
     return SmartTableChartCommon;
-});
+});

package/src/sap/suite/ui/generic/template/genericUtilities/controlStateWrapperFactory/SmartTableWrapper.js

@@ -2,10 +2,29 @@ sap.ui.define([
 	"sap/suite/ui/generic/template/genericUtilities/controlStateWrapperFactory/SmartTableChartCommon"
 ], function(SmartTableChartCommon) {
 	"use strict";
-	
+
+	/**
+	 * Constructor for SmartTableWrapper
+	 * @param {sap.ui.comp.smarttable.SmartTable} oSmartTable - The SmartTable control
+	 * @param {object} oController - The controller instance
+	 * @param {object} oFactory - The ControlStateWrapperFactory instance
+	 * @returns {object} Wrapper object for SmartTable
+	 */
 	function SmartTableWrapper(oSmartTable, oController, oFactory){
-		return new SmartTableChartCommon(oSmartTable, oController, oFactory, "initialise");
+		// SmartTable extends SmartTableChartCommon with tableSettings support
+		return new SmartTableChartCommon(oSmartTable, oController, oFactory, "initialise", {
+			// Extension to add tableSettings to the state
+			fnExtendGetUiState: function(oStateUiState, oControlUiState) {
+				oStateUiState.oTableSettings = oControlUiState.getTableSettings();
+			},
+			// Extension to apply tableSettings from the state
+			fnExtendSetUiState: function(oStateUiState, oControlUiState) {
+				if (oStateUiState.oTableSettings) {
+					oControlUiState.setTableSettings(oStateUiState.oTableSettings);
+				}
+			}
+		});
 	}
 
 	return SmartTableWrapper;
-});
+});

package/src/sap/suite/ui/generic/template/genericUtilities/controlStateWrapperFactory/SmartVariantManagementWrapper.js

@@ -4,18 +4,16 @@ sap.ui.define([
 
 	/**
 	 * Constructor for SmartVariantManagementWrapper
-	 * @param {sap.ui.comp.smartvariants.SmartVariantManagement} vTarget - The SmartVariantManagement control
-	 * or the Id of control for which this wrapper is created
+	 * @param {sap.ui.comp.smartvariants.SmartVariantManagement} oControl - The SmartVariantManagement control
 	 * @param {object} oController - the controller of the current component
 	 * @param {object} oFactory - the controlStateWrapperFactory
 	 * @param {object} mParams
 	 * @param {array} mParams.managedControlWrappers - array of controlStateWrappers for controls handled by the SVM
-	 * (currently also including SFB wrapper - to be removed)
-	 * @param {Object} mParams.dynamicPageWrapper - dynamicPageWrapper instance handled by SVM
+	 * @param {object} mParams.smartFilterBarWrapper - explicit reference to SmartFilterBarWrapper for special handling
 	 * @returns {object}
 	 */
 
-	function SmartVariantManagementWrapper(vTarget, oController, oFactory, mParams) {
+	function SmartVariantManagementWrapper(oControl, oController, oFactory, mParams) {
 		// Special handling of SmartFilterBarWrapper for several reasons:
 		// - Suppress selection when restoring a variant. Selection is solely triggered according to information in appState. Otherwise, erroneous selection could be triggered in
 		//		a few situations:
@@ -26,14 +24,10 @@ sap.ui.define([
 		//	- Store and restore extension state (extension implemented in SFB instead of SVM, which would be more appropriate from architectural point of view)
 		// flag to control whether we are currently in the process of applying a state to suppress the event to inform about a new state´
 		// only needed when setting the variant itself - for managed controls, their wrappers should avoid firing the event themselves
-		var oSmartVariantManagement, fnResolveControlAssigned, oPreliminaryState;
-		var oControlAssignedPromise = new Promise(function (resolve) {
-			fnResolveControlAssigned = resolve;
-		});
-
-		if (typeof vTarget !== "string") {
-            fnSetControl(vTarget);
-        }
+		var oSmartVariantManagement = oControl;
+		var oPreliminaryState;
+		var bIsApplyingVariant = false;
+		var bAllControlsInitialized = false;
 
 		// Handles the state of the variant management itself (i.e. which variant is selected and whether it's dirty), including the state of the managed controls.
 		// Is responsible esp. to restore this state with correct dependency resp. in correct order
@@ -50,69 +44,74 @@ sap.ui.define([
 		// For these controls, a real user changes are already handled by the direct connection. On the other hand, these controls also fire their change events, if their state is
 		// changed from SVM (by the same connection) - setting variant dirty here would be wrong.
 		mParams.managedControlWrappers.forEach(function(oWrapper){
-			if (!oWrapper.bVMConnection){
-				oWrapper.attachStateChanged(function(){
-					oSmartVariantManagement.currentVariantSetModified(true);
-				});
-			}
+			(oWrapper.oVMConnectionPromise || Promise.resolve(oWrapper.bVMConnection)).then(function(bVMConnection) {
+				if (!bVMConnection) {
+					oWrapper.attachStateChanged(function(){
+						oSmartVariantManagement.currentVariantSetModified(true);
+					});
+				}
+			});
 		});
 
+		// Get SmartFilterBarWrapper explicitly from params.
+		// This connection is needed because SmartFilterBar provides special callbacks to store/restore state
+		// for controls that don't have a direct variant management connection (bVMConnection = false), such as:
+		// - Extension filters (custom filters added via app or adaptation extensions)
+		// - Multiple views state (selected tab in multi-table/chart scenarios)
+		// These controls need their state saved/restored with variants via the SFB's beforeVariantFetch/afterVariantLoad events.
+		var oSmartFilterBarWrapper = mParams.smartFilterBarWrapper;
 
-
-		function fnSetControl(oControl) {
-			oSmartVariantManagement = oControl;
-			fnResolveControlAssigned(oSmartVariantManagement);
-		}
-
-		var oSmartFilterBarWrapper = mParams.managedControlWrappers.find(function(oWrapper){
-			return oWrapper.setSVMWrapperCallbacks;
-		});
-
-		// provide callbacks needed for SFB wrapper to store/restore extnesion state with variant
+		// Provide callbacks needed for SFB wrapper to store/restore extension state with variant
 		if (oSmartFilterBarWrapper){
-			oSmartFilterBarWrapper.setSVMWrapperCallbacks({
-				getManagedControlStates: function(){
-					var mManagedControlStates = Object.create(null);
-					mParams.managedControlWrappers.forEach(function(oWrapper){
-						if (!oWrapper.bVMConnection){
-							mManagedControlStates[oWrapper.getLocalId()] = oWrapper.getState();
-						}
-					});
-					return mManagedControlStates;
-				},
-				setManagedControlStates: function(oState){
-					mParams.managedControlWrappers.forEach(function(oWrapper){
-						if (!oWrapper.bVMConnection){
-							oWrapper.setState(oState[oWrapper.getLocalId()]);
-						}
-					});
-				},
-				setHeaderState: function(bHeaderToBeExpanded) {
-					mParams.dynamicPageWrapper.setHeaderState(oController, bHeaderToBeExpanded);
-				}
+			// Build array with wrapper + bVMConnection info once all wrappers are ready
+			Promise.all(mParams.managedControlWrappers.map(function(oWrapper){
+				return (oWrapper.oVMConnectionPromise || Promise.resolve(oWrapper.bVMConnection)).then(function(bVMConnection){
+					return {
+						wrapper: oWrapper,
+						bVMConnection: bVMConnection
+					};
+				});
+			})).then(function(aWrapperInfo) {
+				oSmartFilterBarWrapper.setSVMWrapperCallbacks({
+					getManagedControlStates: function(){
+						var mManagedControlStates = Object.create(null);
+						aWrapperInfo.forEach(function(oInfo){
+							if (!oInfo.bVMConnection) {
+								mManagedControlStates[oInfo.wrapper.getLocalId()] = oInfo.wrapper.getState();
+							}
+						});
+						return mManagedControlStates;
+					},
+					setManagedControlStates: function(oState){
+						aWrapperInfo.forEach(function(oInfo){
+							if (!oInfo.bVMConnection) {
+								oInfo.wrapper.setState(oState[oInfo.wrapper.getLocalId()]);
+							}
+						});
+					}
+				});
 			});
 		}
 
+		// Create promise that resolves when all managed controls' variant management is ready
+		// This ensures getState() can query controls even if setState() is never called (e.g., app starts from scratch)
+		var oAllControlsInitializedPromise = Promise.all(
+			mParams.managedControlWrappers.map(function(oWrapper){
+				return oWrapper.oVariantManagementInitializedPromise || Promise.resolve();
+			})
+		);
+
+		// Set flag when all controls are initialized
+		oAllControlsInitializedPromise.then(function() {
+			bAllControlsInitialized = true;
+		});
+
 		// Wrapper is intended to set a state to the ui, but not to trigger a selection (which should happen only after all (relevant) parts of ui state is set to the correct state
 		// are set correct. Therefore, setting variant from here should never trigger a selection.
 		function fnSetVariant(sVariantId){
 			if (oSmartFilterBarWrapper){
 				oSmartFilterBarWrapper.suppressSelection(true);
 			}
-			var sId = mParams.managedControlWrappers[0].getLocalId();
-			var oControl = oController.getView().byId(sId);
-			if (oControl && oControl.isA("sap.ui.comp.smarttable.SmartTable")) {
-				oControl.attachAfterVariantInitialise(function() {
-					//set currentVariantId only when sVariantId is not standard (as it might be overriding existing
-					//different currentVariantId) or smartTable's (oControl) currentVariantId is not equal to sVariantId.
-					if (sVariantId !== '*standard*' && sVariantId !== '') {
-						if (oControl.getCurrentVariantId && oControl.getCurrentVariantId() !== sVariantId) {
-							oControl.setCurrentVariantId(sVariantId);
-						}
-						oSmartVariantManagement.setModified(false);
-					}
-				});
-			}
 			oSmartVariantManagement.setCurrentVariantId(sVariantId);
 			if (oSmartFilterBarWrapper){
 				oSmartFilterBarWrapper.suppressSelection(false);
@@ -133,7 +132,11 @@ sap.ui.define([
 		}
 
 		function getState() {
-			if (!oSmartVariantManagement) {
+			// Return preliminary state if managed controls not fully initialized
+			// Note: If early getState() calls become an issue (controls not initialized yet), we could enhance this to:
+			// - Store only SVM-specific data (variantId, modified) in oPreliminaryState
+			// - Always query managed control wrappers directly (they handle their own preliminary state via PreliminaryWrapper)
+			if (!bAllControlsInitialized) {
 				return oPreliminaryState;
 			}
 
@@ -150,22 +153,23 @@ sap.ui.define([
 
 		function setState(oState) {
 			oPreliminaryState = oState;
-			oControlAssignedPromise.then(function() {
+
+			// Wait for all managed controls to be initialized before applying state
+			oAllControlsInitializedPromise.then(function() {
+				bIsApplyingVariant = true;
 				if (!oPreliminaryState) {
 					// if no state is provided set default variant (not modified)
 					// use cases:
 					// - LR: if appStateKey in the URL that cannot be read
 					// - OP: if switching to different object instance (in discovery mode always, in persistency mode when page was not shown)
 					fnSetVariant(oSmartVariantManagement.getDefaultVariantId());
-					return;
-				}
-				if (oPreliminaryState.modified) {
+				} else if (oPreliminaryState.modified) {
 					// Special logic according to UX: If variant was modified anyway, there's no benefit for the user to see the name (but it could be confusing), so standard variant (not default!) should be
 					// set (which is achieved by empty string)
 					fnSetVariant("");
+					oSmartVariantManagement.currentVariantSetModified(true);
 					// Usually restoring the state of any of the managed controls should mark the variant as dirty, but there might be edge cases (state from an old release not containing information for any
 					// managed control now relevant), so to be on the safe side, we set modified=true explicitly.
-					oSmartVariantManagement.currentVariantSetModified(true);
 					fnSetManagedControlStates(oPreliminaryState);
 				} else {
 					fnSetVariant(oPreliminaryState.variantId);
@@ -183,6 +187,7 @@ sap.ui.define([
 						}
 					}
 				}
+				bIsApplyingVariant = false;
 			});
 		}
 
@@ -190,26 +195,30 @@ sap.ui.define([
 			// state of variant management itself can be changed directly (user selects a different variant or stores current state as (new) variant), or indirectly (user changes some
 			// data of a control managed by VM, e.g. some filter values in SFB)
 
-			oControlAssignedPromise.then(function() {
-				// state change when user selects a different variant
-				oSmartVariantManagement.attachSelect(fnHandler);
+			// Wrap the handler to suppress events when applying a variant
+			var fnSuppressibleHandler = function() {
+				if (!bIsApplyingVariant) {
+					fnHandler();
+				}
+			};
 
-				// when user saves current state as a new variant, this is also a state change (as the variant id is part of the state)
-				// note: Even if new (SFB) variant is marked as execute on select, and currently no data is selected, no need to select data here (and thus also not to collapse header).
-				// This is one of the possible ways to get into a state with a clean variant with execute on select, but no data loaded - see also comment to identify SFB wrapper.
-				oSmartVariantManagement.attachAfterSave(fnHandler);
+			// state change when user selects a different variant
+			oSmartVariantManagement.attachSelect(fnSuppressibleHandler);
 
-				// any change of a managed control is state change
-				mParams.managedControlWrappers.forEach(function(oWrapper){
-					oWrapper.attachStateChanged(fnHandler);
-				});
+			// when user saves current state as a new variant, this is also a state change (as the variant id is part of the state)
+			// note: Even if new (SFB) variant is marked as execute on select, and currently no data is selected, no need to select data here (and thus also not to collapse header).
+			// This is one of the possible ways to get into a state with a clean variant with execute on select, but no data loaded - see also comment to identify SFB wrapper.
+			oSmartVariantManagement.attachAfterSave(fnSuppressibleHandler);
+
+			// any change of a managed control is state change
+			mParams.managedControlWrappers.forEach(function(oWrapper){
+				oWrapper.attachStateChanged(fnSuppressibleHandler);
 			});
 		}
 
 		return {
 			getState : getState,
 			setState : setState,
-			setControl: fnSetControl,
 			attachStateChanged : attachStateChanged
 		};
 	}

package/src/sap/suite/ui/generic/template/lib/AppComponent.js

@@ -959,7 +959,7 @@ sap.ui.define([
 	 * @public
 	 * @extends sap.ui.core.UIComponent
 	 * @author SAP SE
-	 * @version 1.145.0
+	 * @version 1.145.2
 	 * @name sap.suite.ui.generic.template.lib.AppComponent
 	 */
 	var oAppComponent = UIComponent.extend("sap.suite.ui.generic.template.lib.AppComponent", {

package/src/sap/suite/ui/generic/template/lib/navigation/NavigationController.js

@@ -3213,7 +3213,7 @@ sap.ui.define(["sap/ui/base/Object",
 	 * @param {sap.suite.ui.generic.template.lib.AppComponent} oAppComponent The AppComponent instance
 	 * @public
 	 * @extends sap.ui.base.Object
-	 * @version 1.145.0
+	 * @version 1.145.2
 	 * @since 1.30.0
 	 * @alias sap.suite.ui.generic.template.lib.NavigationController
 	 */

package/src/sap/suite/ui/generic/template/library.js

@@ -66,7 +66,7 @@ sap.ui.define([
 		interfaces: [],
 		controls: [],
 		elements: [],
-		version: "1.145.0",
+		version: "1.145.2",
 		extensions: {
 			//Configuration used for rule loading of Support Assistant
 			"sap.ui.support": {