@sapui5/sap.fe.core 1.97.0 → 1.100.0

package/src/sap/fe/core/controllerextensions/ViewState.ts

@@ -0,0 +1,805 @@
+import ControllerExtension from "sap/ui/core/mvc/ControllerExtension";
+import OverrideExecution from "sap/ui/core/mvc/OverrideExecution";
+import Log from "sap/base/Log";
+import mergeObjects from "sap/base/util/merge";
+import ControlVariantApplyAPI from "sap/ui/fl/apply/api/ControlVariantApplyAPI";
+import StateUtil from "sap/ui/mdc/p13n/StateUtil";
+import NavLibrary from "sap/fe/navigation/library";
+import CommonUtils from "sap/fe/core/CommonUtils";
+import KeepAliveHelper from "sap/fe/core/helpers/KeepAliveHelper";
+import ModelHelper from "sap/fe/core/helpers/ModelHelper";
+import { Extensible, Final, Private, Public, UI5Class } from "sap/fe/core/helpers/ClassSupport";
+import ControllerExtensionMetadata from "sap/fe/core/controllerextensions/ControllerExtensionMetadata";
+import PageController from "sap/fe/core/PageController";
+import ManagedObject from "sap/ui/base/ManagedObject";
+// additionalStates are stored next to control IDs, so name clash avoidance needed. Fortunately IDs have restrictions:
+// "Allowed is a sequence of characters (capital/lowercase), digits, underscores, dashes, points and/or colons."
+// Therefore adding a symbol like # or @
+const ADDITIONAL_STATES_KEY = "#additionalStates",
+	NavType = NavLibrary.NavType;
+///////////////////////////////////////////////////////////////////
+// methods to retrieve & apply states for the different controls //
+///////////////////////////////////////////////////////////////////
+const _mControlStateHandlerMap: Record<string, any> = {
+	"sap.ui.fl.variants.VariantManagement": {
+		retrieve: function(oVM: any) {
+			return {
+				"variantId": oVM.getCurrentVariantKey()
+			};
+		},
+		apply: function(oVM: any, oControlState: any) {
+			if (oControlState && oControlState.variantId !== undefined && oControlState.variantId !== oVM.getCurrentVariantKey()) {
+				const sVariantReference = this._checkIfVariantIdIsAvailable(oVM, oControlState.variantId)
+					? oControlState.variantId
+					: oVM.getStandardVariantKey();
+				return ControlVariantApplyAPI.activateVariant({
+					element: oVM,
+					variantReference: sVariantReference
+				});
+			}
+		}
+	},
+	"sap.m.IconTabBar": {
+		retrieve: function(oTabBar: any) {
+			return {
+				selectedKey: oTabBar.getSelectedKey()
+			};
+		},
+		apply: function(oTabBar: any, oControlState: any) {
+			if (oControlState && oControlState.selectedKey) {
+				const oSelectedItem = oTabBar.getItems().find(function(oItem: any) {
+					return oItem.getKey() === oControlState.selectedKey;
+				});
+				if (oSelectedItem) {
+					oTabBar.setSelectedItem(oSelectedItem);
+				}
+			}
+		}
+	},
+	"sap.ui.mdc.FilterBar": {
+		retrieve: function(oFilterBar: any) {
+			return StateUtil.retrieveExternalState(oFilterBar).then(function(mFilterBarState: any) {
+				// remove sensitive or view state irrelevant fields
+				const aPropertiesInfo = oFilterBar.getPropertyInfoSet(),
+					mFilter = mFilterBarState.filter || {};
+				aPropertiesInfo
+					.filter(function(oPropertyInfo: any) {
+						return (
+							mFilter[oPropertyInfo.path] && (oPropertyInfo.removeFromAppState || mFilter[oPropertyInfo.path].length === 0)
+						);
+					})
+					.forEach(function(oPropertyInfo: any) {
+						delete mFilter[oPropertyInfo.path];
+					});
+				return mFilterBarState;
+			});
+		},
+		apply: function(oFilterBar: any, oControlState: any) {
+			if (oControlState) {
+				return StateUtil.applyExternalState(oFilterBar, oControlState);
+			}
+		}
+	},
+	"sap.ui.mdc.Table": {
+		retrieve: function(oTable: any) {
+			return StateUtil.retrieveExternalState(oTable);
+		},
+		apply: function(oTable: any, oControlState: any) {
+			if (oControlState) {
+				return StateUtil.applyExternalState(oTable, oControlState);
+			}
+		},
+		refreshBinding: function(oTable: any) {
+			const oTableBinding = oTable.getRowBinding();
+			if (oTableBinding) {
+				const oRootBinding = oTableBinding.getRootBinding();
+				if (oRootBinding === oTableBinding) {
+					// absolute binding
+					oTableBinding.refresh();
+				} else {
+					// relative binding
+					const oHeaderContext = oTableBinding.getHeaderContext();
+					const sGroupId = oTableBinding.getGroupId();
+
+					if (oHeaderContext) {
+						oHeaderContext.requestSideEffects([{ $NavigationPropertyPath: "" }], sGroupId);
+					}
+				}
+			} else {
+				Log.info("Table: " + oTable.getId() + " was not refreshed. No binding found!");
+			}
+		}
+	},
+	"sap.uxap.ObjectPageLayout": {
+		retrieve: function(oOPLayout: any) {
+			return {
+				selectedSection: oOPLayout.getSelectedSection()
+			};
+		},
+		apply: function(oOPLayout: any, oControlState: any) {
+			oControlState && oOPLayout.setSelectedSection(oControlState.selectedSection);
+		},
+		refreshBinding: function(oOPLayout: any) {
+			const oBindingContext = oOPLayout.getBindingContext();
+			const oBinding = oBindingContext && oBindingContext.getBinding();
+			if (oBinding) {
+				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: any[], sNavProp: string) {
+							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!");
+			}
+		}
+	},
+	"sap.fe.macros.table.QuickFilterContainer": {
+		retrieve: function(oQuickFilter: any) {
+			return {
+				selectedKey: oQuickFilter.getSelectorKey()
+			};
+		},
+		apply: function(oQuickFilter: any, oControlState: any) {
+			oControlState && oQuickFilter.setSelectorKey(oControlState.selectedKey);
+		}
+	},
+	"sap.m.SegmentedButton": {
+		retrieve: function(oSegmentedButton: any) {
+			return {
+				selectedKey: oSegmentedButton.getSelectedKey()
+			};
+		},
+		apply: function(oSegmentedButton: any, oControlState: any) {
+			oControlState && oSegmentedButton.setSelectedKey(oControlState.selectedKey);
+		}
+	},
+	"sap.m.Select": {
+		retrieve: function(oSelect: any) {
+			return {
+				selectedKey: oSelect.getSelectedKey()
+			};
+		},
+		apply: function(oSelect: any, oControlState: any) {
+			oControlState && oSelect.setSelectedKey(oControlState.selectedKey);
+		}
+	},
+	"sap.f.DynamicPage": {
+		retrieve: function(oDynamicPage: any) {
+			return {
+				headerExpanded: oDynamicPage.getHeaderExpanded()
+			};
+		},
+		apply: function(oDynamicPage: any, oControlState: any) {
+			oControlState && oDynamicPage.setHeaderExpanded(oControlState.headerExpanded);
+		}
+	},
+	"sap.ui.core.mvc.View": {
+		retrieve: function(oView: any) {
+			const oController = oView.getController();
+			if (oController && oController.viewState) {
+				return oController.viewState.retrieveViewState(oController.viewState);
+			}
+			return {};
+		},
+		apply: function(oView: any, oControlState: any, oNavParameters: any) {
+			const oController = oView.getController();
+			if (oController && oController.viewState) {
+				return oController.viewState.applyViewState(oControlState, oNavParameters);
+			}
+		},
+		refreshBinding: function(oView: any) {
+			const oController = oView.getController();
+			if (oController && oController.viewState) {
+				return oController.viewState.refreshViewBindings();
+			}
+		}
+	},
+	"sap.ui.core.ComponentContainer": {
+		retrieve: function(oComponentContainer: any) {
+			const oComponent = oComponentContainer.getComponentInstance();
+			if (oComponent) {
+				return this.retrieveControlState(oComponent.getRootControl());
+			}
+			return {};
+		},
+		apply: function(oComponentContainer: any, oControlState: any, oNavParameters: any) {
+			const oComponent = oComponentContainer.getComponentInstance();
+			if (oComponent) {
+				return this.applyControlState(oComponent.getRootControl(), oControlState, oNavParameters);
+			}
+		}
+	}
+};
+/**
+ * A controller extension offering hooks for state handling
+ *
+ * If you need to maintain a specific state for your application, you can use the controller extension.
+ *
+ * @hideconstructor
+ * @public
+ * @since 1.85.0
+ */
+@UI5Class("sap.fe.core.controllerextensions.ViewState", ControllerExtensionMetadata)
+class ViewState extends ControllerExtension {
+	private _iRetrievingStateCounter: number;
+	private _pInitialStateApplied: Promise<unknown>;
+	private _pInitialStateAppliedResolve?: Function;
+	private base!: PageController;
+
+	/**
+	 * Constructor.
+	 */
+	constructor() {
+		super();
+		this._iRetrievingStateCounter = 0;
+		this._pInitialStateApplied = new Promise(resolve => {
+			this._pInitialStateAppliedResolve = resolve;
+		});
+	}
+
+	/**
+	 * @private
+	 * @name sap.fe.core.controllerextensions.ViewState.getMetadata
+	 * @function
+	 */
+	/**
+	 * @private
+	 * @name sap.fe.core.controllerextensions.ViewState.extend
+	 * @function
+	 */
+
+	@Public
+	@Final
+	refreshViewBindings() {
+		return this.collectResults(this.base.viewState.adaptBindingRefreshControls).then((aControls: any) => {
+			let oPromiseChain = Promise.resolve();
+			aControls
+				.filter((oControl: any) => {
+					return oControl && oControl.isA && oControl.isA("sap.ui.base.ManagedObject");
+				})
+				.forEach((oControl: any) => {
+					oPromiseChain = oPromiseChain.then(this.refreshControlBinding.bind(this, oControl));
+				});
+			return oPromiseChain;
+		});
+	}
+	/**
+	 * This function should add all controls relevant for refreshing to the provided control array.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+	 * @param {Array<sap.ui.base.ManagedObject>} aCollectedControls The collected controls
+	 * @alias sap.fe.core.controllerextensions.ViewState#adaptBindingRefreshControls
+	 * @protected
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	adaptBindingRefreshControls(aCollectedControls: ManagedObject[]) {
+		// to be overriden
+	}
+
+	@Private
+	@Final
+	refreshControlBinding(oControl: any) {
+		const oControlRefreshBindingHandler = this.getControlRefreshBindingHandler(oControl);
+		let oPromiseChain = Promise.resolve();
+		if (typeof oControlRefreshBindingHandler.refreshBinding !== "function") {
+			Log.info("refreshBinding handler for control: " + oControl.getMetadata().getName() + " is not provided");
+		} else {
+			oPromiseChain = oPromiseChain.then(oControlRefreshBindingHandler.refreshBinding.bind(this, oControl));
+		}
+		return oPromiseChain;
+	}
+
+	/**
+	 * Returns a map of <code>refreshBinding</code> function for a certain control.
+	 *
+	 * @param {sap.ui.base.ManagedObject} oControl The control to get state handler for
+	 * @returns {object} A plain object with one function: <code>refreshBinding</code>
+	 */
+
+	@Private
+	@Final
+	getControlRefreshBindingHandler(oControl: any): any {
+		const oRefreshBindingHandler: any = {};
+		if (oControl) {
+			for (const sType in _mControlStateHandlerMap) {
+				if (oControl.isA(sType)) {
+					// pass only the refreshBinding handler in an object so that :
+					// 1. Application has access only to refreshBinding and not apply and reterive at this stage
+					// 2. Application modifications to the object will be reflected here (as we pass by reference)
+					oRefreshBindingHandler["refreshBinding"] = _mControlStateHandlerMap[sType].refreshBinding || {};
+					break;
+				}
+			}
+		}
+		this.base.viewState.adaptBindingRefreshHandler(oControl, oRefreshBindingHandler);
+		return oRefreshBindingHandler;
+	}
+	/**
+	 * Customize the <code>refreshBinding</code> function for a certain control.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+	 *
+	 * @param {sap.ui.base.ManagedObject} oControl The control for which the refresh handler is adapted.
+	 * @param {Array<object>} oControlHandler A plain object which can have one function: <code>refreshBinding</code>
+	 *
+	 * @alias sap.fe.core.controllerextensions.ViewState#adaptBindingRefreshHandler
+	 * @protected
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	adaptBindingRefreshHandler(oControl: ManagedObject, oControlHandler: any[]) {
+		// to be overriden
+	}
+
+	/**
+	 * Called when the application is suspended due to keep-alive mode.
+	 *
+	 * @alias sap.fe.core.controllerextensions.ViewState#onSuspend
+	 * @public
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	onSuspend() {
+		// to be overriden
+	}
+
+	/**
+	 * Called when the application is restored due to keep-alive mode.
+	 *
+	 * @alias sap.fe.core.controllerextensions.ViewState#onRestore
+	 * @public
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	onRestore() {
+		// to be overriden
+	}
+
+	/**
+	 * Destructor method for objects.
+	 */
+	destroy() {
+		delete this._pInitialStateAppliedResolve;
+		super.destroy();
+	}
+
+	/**
+	 * Helper function to enable multi override. It is adding an additional parameter (array) to the provided
+	 * function (and its parameters), that will be evaluated via <code>Promise.all</code>.
+	 *
+	 * @param {Function} fnCall The function to be called
+	 * @param args
+	 * @returns {Promise} A promise to be resolved with the result of all overrides
+	 */
+	@Private
+	@Final
+	collectResults(fnCall: Function, ...args: any[]) {
+		const aResults: any[] = [];
+		args.push(aResults);
+		fnCall.apply(this, args);
+		return Promise.all(aResults);
+	}
+
+	/**
+	 * Customize the <code>retrieve</code> and <code>apply</code> functions for a certain control.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+	 *
+	 * @param {sap.ui.base.ManagedObject} oControl The control to get state handler for
+	 * @param {Array<object>} aControlHandler A list of plain objects with two functions: <code>retrieve</code> and <code>apply</code>
+	 *
+	 * @alias sap.fe.core.controllerextensions.ViewState#adaptControlStateHandler
+	 * @protected
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	adaptControlStateHandler(oControl: ManagedObject, aControlHandler: object[]) {
+		// to be overridden if needed
+	}
+
+	/**
+	 * Returns a map of <code>retrieve</code> and <code>apply</code> functions for a certain control.
+	 *
+	 * @param {sap.ui.base.ManagedObject} oControl The control to get state handler for
+	 * @returns {object} A plain object with two functions: <code>retrieve</code> and <code>apply</code>
+	 */
+	@Private
+	@Final
+	getControlStateHandler(oControl: any) {
+		const aInternalControlStateHandler = [],
+			aCustomControlStateHandler: any[] = [];
+		if (oControl) {
+			for (const sType in _mControlStateHandlerMap) {
+				if (oControl.isA(sType)) {
+					// avoid direct manipulation of internal _mControlStateHandlerMap
+					aInternalControlStateHandler.push(Object.assign({}, _mControlStateHandlerMap[sType]));
+					break;
+				}
+			}
+		}
+		this.base.viewState.adaptControlStateHandler(oControl, aCustomControlStateHandler);
+		return aInternalControlStateHandler.concat(aCustomControlStateHandler);
+	}
+
+	/**
+	 * This function should add all controls for given view that should be considered for the state handling to the provided control array.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+	 * @param {Array<sap.ui.base.ManagedObject>} aCollectedControls The collected controls
+	 * @alias sap.fe.core.controllerextensions.ViewState#adaptStateControls
+	 * @protected
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	adaptStateControls(aCollectedControls: ManagedObject[]) {
+		// to be overridden if needed
+	}
+
+	/**
+	 * Returns the key to be used for given control.
+	 *
+	 * @param {sap.ui.base.ManagedObject} oControl The control to get state key for
+	 * @returns {string} The key to be used for storing the controls state
+	 */
+	@Public
+	@Final
+	getStateKey(oControl: any) {
+		return this.getView().getLocalId(oControl.getId()) || oControl.getId();
+	}
+
+	/**
+	 * Retrieve the view state of this extensions view.
+	 * When this function is called more than once before finishing, all but the final response will resolve to <code>undefined</code>.
+	 *
+	 * @returns {Promise} A promise resolving the view state
+	 *
+	 * @alias sap.fe.core.controllerextensions.ViewState#retrieveViewState
+	 * @public
+	 */
+	@Public
+	@Final
+	retrieveViewState() {
+		++this._iRetrievingStateCounter;
+		return this._pInitialStateApplied
+			.then(() => {
+				return this.collectResults(this.base.viewState.adaptStateControls);
+			})
+			.then((aControls: any) => {
+				return Promise.all(
+					aControls
+						.filter(function(oControl: any) {
+							return oControl && oControl.isA && oControl.isA("sap.ui.base.ManagedObject");
+						})
+						.map((oControl: any) => {
+							return this.retrieveControlState(oControl).then((vResult: any) => {
+								return {
+									key: this.getStateKey(oControl),
+									value: vResult
+								};
+							});
+						})
+				);
+			})
+			.then(function(aResolvedStates: any) {
+				return aResolvedStates.reduce(function(oStates: any, mState: any) {
+					const oCurrentState: any = {};
+					oCurrentState[mState.key] = mState.value;
+					return mergeObjects(oStates, oCurrentState);
+				}, {});
+			})
+			.then((oViewState: any) => {
+				return Promise.resolve(this._retrieveAdditionalStates()).then(function(mAdditionalStates: any) {
+					if (mAdditionalStates && Object.keys(mAdditionalStates).length) {
+						oViewState[ADDITIONAL_STATES_KEY] = mAdditionalStates;
+					}
+					return oViewState;
+				});
+			})
+			.finally(() => {
+				--this._iRetrievingStateCounter;
+			})
+			.then((oViewState: any) => {
+				return this._iRetrievingStateCounter === 0 ? oViewState : undefined;
+			});
+	}
+
+	/**
+	 * Extend the map of additional states (not control bound) to be added to the current view state of the given view.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+	 *
+	 * @param {object} mAdditionalStates The additional state
+	 *
+	 * @alias sap.fe.core.controllerextensions.ViewState#retrieveAdditionalStates
+	 * @protected
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	retrieveAdditionalStates(mAdditionalStates: object) {
+		// to be overridden if needed
+	}
+
+	/**
+	 * Returns a map of additional states (not control bound) to be added to the current view state of the given view.
+	 *
+	 * @returns {object | Promise<object>} Additional view states
+	 */
+	_retrieveAdditionalStates() {
+		const mAdditionalStates = {};
+		this.base.viewState.retrieveAdditionalStates(mAdditionalStates);
+		return mAdditionalStates;
+	}
+
+	/**
+	 * Returns the current state for the given control.
+	 *
+	 * @param {sap.ui.base.ManagedObject} oControl The object to get the state for
+	 * @returns {Promise<object>} The state for the given control
+	 */
+	@Private
+	@Final
+	retrieveControlState(oControl: any) {
+		const aControlStateHandlers = this.getControlStateHandler(oControl);
+		return Promise.all(
+			aControlStateHandlers.map((mControlStateHandler: any) => {
+				if (typeof mControlStateHandler.retrieve !== "function") {
+					throw new Error("controlStateHandler.retrieve is not a function for control: " + oControl.getMetadata().getName());
+				}
+				return mControlStateHandler.retrieve.call(this, oControl);
+			})
+		).then((aStates: any[]) => {
+			return aStates.reduce(function(oFinalState: any, oCurrentState: any) {
+				return mergeObjects(oFinalState, oCurrentState);
+			}, {});
+		});
+	}
+
+	/**
+	 * Defines whether the view state should only be applied once initially.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.Instead}.
+	 *
+	 * Important:
+	 * You should only override this method for custom pages and not for the standard ListReportPage and ObjectPage!
+	 *
+	 * @returns {boolean} If <code>true</code>, only the initial view state is applied once,
+	 * else any new view state is also applied on follow-up calls (default)
+	 *
+	 * @alias sap.fe.core.controllerextensions.ViewState#applyInitialStateOnly
+	 * @protected
+	 */
+	@Public
+	@Extensible(OverrideExecution.Instead)
+	applyInitialStateOnly() {
+		return true;
+	}
+	/**
+	 * Applies the given view state to this extensions view.
+	 *
+	 * @param {object} oViewState The view state to apply (can be undefined)
+	 * @param {object} oNavParameter The current navigation parameter
+	 * @param {sap.fe.navigation.NavType} oNavParameter.navigationType The actual navigation type
+	 * @param {object} oNavParameter.selectionVariant The selectionVariant from the navigation
+	 * @param {object} oNavParameter.selectionVariantDefaults The selectionVariant defaults from the navigation
+	 * @param {boolean} oNavParameter.requiresStandardVariant Defines whether standard variant must be used in VM
+	 *
+	 * @returns {Promise} Promise for async state handling
+	 *
+	 * @alias sap.fe.core.controllerextensions.ViewState#applyViewState
+	 * @public
+	 */
+	@Public
+	@Final
+	applyViewState(
+		oViewState: any,
+		oNavParameter: {
+			navigationType: any;
+			selectionVariant?: object;
+			selectionVariantDefaults?: object;
+			requiresStandardVariant?: boolean;
+		}
+	): Promise<any> {
+		if (this.base.viewState.applyInitialStateOnly() && this._getInitialStateApplied()) {
+			return Promise.resolve();
+		}
+		return this.collectResults(this.base.viewState.onBeforeStateApplied)
+			.then(() => {
+				return this.collectResults(this.base.viewState.adaptStateControls);
+			})
+			.then((aControls: any) => {
+				let oPromiseChain = Promise.resolve();
+				aControls
+					.filter(function(oControl: any) {
+						return oControl && oControl.isA && oControl.isA("sap.ui.base.ManagedObject");
+					})
+					.forEach((oControl: any) => {
+						const sKey = this.getStateKey(oControl);
+						oPromiseChain = oPromiseChain.then(
+							this.applyControlState.bind(this, oControl, oViewState ? oViewState[sKey] : undefined, oNavParameter)
+						);
+					});
+				return oPromiseChain;
+			})
+			.then(() => {
+				if (oNavParameter.navigationType === NavType.iAppState) {
+					return this.collectResults(
+						this.base.viewState.applyAdditionalStates,
+						oViewState ? oViewState[ADDITIONAL_STATES_KEY] : undefined
+					);
+				} else {
+					return this.collectResults(this.base.viewState.applyNavigationParameters, oNavParameter);
+				}
+			})
+			.finally(() => {
+				return this.collectResults(this.base.viewState.onAfterStateApplied).then(this._setInitialStateApplied.bind(this));
+			});
+	}
+
+	@Private
+	_checkIfVariantIdIsAvailable(oVM: any, sVariantId: any) {
+		const aVariants = oVM.getVariants();
+		let bIsControlStateVariantAvailable = false;
+		aVariants.forEach(function(oVariant: any) {
+			if (oVariant.key === sVariantId) {
+				bIsControlStateVariantAvailable = true;
+			}
+		});
+		return bIsControlStateVariantAvailable;
+	}
+
+	_setInitialStateApplied() {
+		if (this._pInitialStateAppliedResolve) {
+			const pInitialStateAppliedResolve = this._pInitialStateAppliedResolve;
+			delete this._pInitialStateAppliedResolve;
+			pInitialStateAppliedResolve();
+		}
+	}
+	_getInitialStateApplied() {
+		return !this._pInitialStateAppliedResolve;
+	}
+
+	/**
+	 * Hook to react before a state for given view is applied.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+	 *
+	 * @param {Promise} aPromises Extensible array of promises to be resolved before continuing
+	 *
+	 * @alias sap.fe.core.controllerextensions.ViewState#onBeforeStateApplied
+	 * @protected
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	onBeforeStateApplied(aPromises: Promise<any>) {
+		// to be overriden
+	}
+
+	/**
+	 * Hook to react when state for given view was applied.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+	 *
+	 * @param {Promise} aPromises Extensible array of promises to be resolved before continuing
+	 *
+	 * @alias sap.fe.core.controllerextensions.ViewState#onAfterStateApplied
+	 * @protected
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	onAfterStateApplied(aPromises: Promise<any>) {
+		// to be overriden
+	}
+
+	/**
+	 * Applying additional, not control related, states - is called only if navigation type is iAppState.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+	 *
+	 * @param {object} oViewState The current view state
+	 * @param {Promise} aPromises Extensible array of promises to be resolved before continuing
+	 *
+	 * @alias sap.fe.core.controllerextensions.ViewState#applyAdditionalStates
+	 * @protected
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	applyAdditionalStates(oViewState: object, aPromises: Promise<any>) {
+		// to be overridden if needed
+	}
+
+	/**
+	 * Apply navigation parameters - is called only if navigation type is not iAppState.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+	 *
+	 * @param {object} oNavParameter The current navigation parameter
+	 * @param {sap.fe.navigation.NavType} oNavParameter.navigationType The actual navigation type
+	 * @param {object} [oNavParameter.selectionVariant] The selectionVariant from the navigation
+	 * @param {object} [oNavParameter.selectionVariantDefaults] The selectionVariant defaults from the navigation
+	 * @param {boolean} [oNavParameter.requiresStandardVariant] Defines whether standard variant must be used in VM
+	 * @param {Promise} aPromises Extensible array of promises to be resolved before continuing
+	 *
+	 * @alias sap.fe.core.controllerextensions.ViewState#applyNavigationParameters
+	 * @protected
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	applyNavigationParameters(
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		oNavParameter: {
+			navigationType: any;
+			selectionVariant?: object | undefined;
+			selectionVariantDefaults?: object | undefined;
+			requiresStandardVariant?: boolean | undefined;
+		},
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		aPromises: Promise<any>
+	) {
+		// to be overridden if needed
+	}
+
+	/**
+	 * Applying the given state to the given control.
+	 *
+	 * @param {sap.ui.base.ManagedObject} oControl The object to apply the given state
+	 * @param {object} oControlState The state for the given control
+	 * @param {object} [oNavParameters] The current navigation parameters
+	 * @returns {any} Return a promise for async state handling
+	 */
+	@Private
+	@Final
+	applyControlState(oControl: any, oControlState: object, oNavParameters?: object) {
+		const aControlStateHandlers = this.getControlStateHandler(oControl);
+		let oPromiseChain = Promise.resolve();
+		aControlStateHandlers.forEach((mControlStateHandler: any) => {
+			if (typeof mControlStateHandler.apply !== "function") {
+				throw new Error("controlStateHandler.apply is not a function for control: " + oControl.getMetadata().getName());
+			}
+			oPromiseChain = oPromiseChain.then(mControlStateHandler.apply.bind(this, oControl, oControlState, oNavParameters));
+		});
+		return oPromiseChain;
+	}
+	getInterface() {
+		return this;
+	}
+}
+
+export default ViewState;