@sapui5/sap.fe.core 1.120.16 → 1.120.18

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sapui5/sap.fe.core",
-	"version": "1.120.16",
+	"version": "1.120.18",
 	"description": "SAPUI5 Library sap.fe.core",
 	"keywords": [
 		"sapui5",

package/src/sap/fe/core/.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.16</version>
+	<version>1.120.18</version>
 
 	<documentation>UI5 library: sap.fe.core</documentation>
 

package/src/sap/fe/core/AppStateHandler.js

@@ -11,6 +11,7 @@ sap.ui.define(["sap/base/Log", "sap/base/util/deepEqual", "sap/fe/core/helpers/C
   function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
   const NavType = library.NavType;
   const SKIP_MERGE_KEY = "skipMerge";
+  const REPLACE_COMPLETE_APPSTATE = "REPLACE_COMPLETE_APPSTATE";
   let AppStateHandler = (_dec = defineUI5Class("sap.fe.core.AppStateHandler"), _dec(_class = /*#__PURE__*/function (_BaseObject) {
     _inheritsLoose(AppStateHandler, _BaseObject);
     function AppStateHandler(oAppComponent) {
@@ -19,7 +20,7 @@ sap.ui.define(["sap/base/Log", "sap/base/util/deepEqual", "sap/fe/core/helpers/C
       _this._mCurrentAppState = {};
       _this.oAppComponent = oAppComponent;
       _this.sId = `${oAppComponent.getId()}/AppStateHandler`;
-      _this.nbSimultaneousCreateRequest = 0;
+      _this.simultaneousCreateRequest = {};
       _this.bNoRouteChange = false;
       Log.info("APPSTATE : Appstate handler initialized");
       return _this;
@@ -29,6 +30,116 @@ sap.ui.define(["sap/base/Log", "sap/base/util/deepEqual", "sap/fe/core/helpers/C
       return this.sId;
     }
 
+    /**
+     * Get the view-specific appstate.
+     *
+     * @param innerAppState Overall appstate
+     * @param stateIdentifier State identifier, id of the local view
+     * @returns Inner appstate
+     */;
+    _proto._getInnerAppStateForView = function _getInnerAppStateForView(innerAppState, stateIdentifier) {
+      if (stateIdentifier === REPLACE_COMPLETE_APPSTATE || !innerAppState) {
+        // overall app state needs to be considered.
+        return innerAppState;
+      }
+
+      // we take the subset of the app state wrt to the local view id.
+      return {
+        [stateIdentifier]: innerAppState[stateIdentifier] || {}
+      };
+    }
+
+    /**
+     * Add appstate in hash.
+     *
+     * @param appStateKey Appstate key
+     * @param stateIdentifier State identifier, Id of the local view
+     */;
+    _proto._addAppStateInHash = function _addAppStateInHash(appStateKey, stateIdentifier) {
+      const appComponent = this.oAppComponent,
+        navigationService = appComponent.getNavigationService(),
+        routerProxy = appComponent.getRouterProxy(),
+        hash = routerProxy.getHash(),
+        isStickyMode = ModelHelper.isStickySessionSupported(appComponent.getMetaModel()),
+        newHash = navigationService.replaceInnerAppStateKey(routerProxy.getFullHash(), appStateKey);
+      if (this.simultaneousCreateRequest[stateIdentifier] === 0 && newHash !== hash) {
+        routerProxy.navToHash(newHash, undefined, undefined, undefined, !isStickyMode);
+        this.bNoRouteChange = true;
+      }
+      Log.info("APPSTATE: navToHash");
+    }
+
+    /**
+     * Create Appstate Key.
+     *
+     * @param appStateData Appstate
+     * @param stateIdentifier State identifier, Id of the local view
+     * @returns Appstate Key
+     */;
+    _proto._createAppStateKey = async function _createAppStateKey(appStateData, stateIdentifier) {
+      const appComponent = this.oAppComponent,
+        navigationService = appComponent.getNavigationService();
+      if (this.simultaneousCreateRequest[stateIdentifier]) {
+        // any other value
+        this.simultaneousCreateRequest[stateIdentifier]++;
+      } else {
+        // 0 or undefined
+        this.simultaneousCreateRequest[stateIdentifier] = 1;
+      }
+      const appStateKey = await navigationService.storeInnerAppStateAsync(appStateData, true, true);
+      this.simultaneousCreateRequest[stateIdentifier]--;
+      Log.info("APPSTATE: Appstate stored");
+      return appStateKey;
+    }
+
+    /**
+     * Creates appstate info.
+     *
+     * @param innerAppState
+     * @param createAppParameters Parameters for creating a new appstate
+     * @param createAppParameters.replaceHash A Boolean that determines whether to replace the hash with the newly generated key
+     * @param createAppParameters.viewId Id of the view for which we need to create the app state. This allows us to create or update view-specific appstate.
+     * @returns A promise that resolves the stored data or appstate keys
+     */;
+    _proto._getAppStateInfo = async function _getAppStateInfo(innerAppState, createAppParameters) {
+      const appComponent = this.oAppComponent;
+      const {
+        replaceHash = true,
+        viewId: stateIdentifier = REPLACE_COMPLETE_APPSTATE
+      } = createAppParameters ?? {};
+      let appStateKey = null;
+      let appStateData = {
+        appState: this._mCurrentAppState
+      };
+      const currentStateToUpdate = this._getInnerAppStateForView(this._mCurrentAppState, stateIdentifier);
+      if (innerAppState && !deepEqual(currentStateToUpdate, innerAppState)) {
+        //
+        this._mCurrentAppState = {
+          ...this._mCurrentAppState,
+          ...innerAppState
+        };
+        appStateData = {
+          appState: this._mCurrentAppState
+        };
+        try {
+          appStateKey = await this._createAppStateKey(appStateData, stateIdentifier);
+          if (replaceHash === true) {
+            this._addAppStateInHash(appStateKey, stateIdentifier);
+          }
+        } catch (oError) {
+          Log.error(oError);
+        }
+      } else {
+        const routerProxy = appComponent.getRouterProxy(),
+          hash = routerProxy.getHash();
+        appStateKey = routerProxy.findAppStateInHash(hash);
+      }
+      return {
+        appStateData,
+        appStateKey
+      };
+    }
+
     /**
      * Creates or updates the appstate.
      * Replaces the hash with the new appstate based on replaceHash
@@ -36,25 +147,32 @@ sap.ui.define(["sap/base/Log", "sap/base/util/deepEqual", "sap/fe/core/helpers/C
      * @param createAppParameters Parameters for creating new appstate
      * @param createAppParameters.replaceHash Boolean which determines to replace the hash with the new generated key
      * @param createAppParameters.skipMerge Boolean which determines to skip the key user shine through
-     * @returns A promise resolving the stored data or appstate key based on returnKey property
+     * @param createAppParameters.viewId Id of the view for which we need to create the app state. This allows us to create or update view-specific appstate.
+     * @returns A promise resolving the stored data or appstate key
      */;
     _proto.createAppState = async function createAppState(createAppParameters) {
-      if (!this.oAppComponent.getEnvironmentCapabilities().getCapabilities().AppState || BusyLocker.isLocked(this)) {
+      const appComponent = this.oAppComponent;
+      if (!appComponent.getEnvironmentCapabilities().getCapabilities().AppState || BusyLocker.isLocked(this)) {
         return;
       }
       const {
-        replaceHash = true,
-        skipMerge = false
-      } = createAppParameters || {};
-      const navigationService = this.oAppComponent.getNavigationService(),
-        routerProxy = this.oAppComponent.getRouterProxy(),
-        hash = routerProxy.getHash(),
-        controller = this.oAppComponent.getRootControl().getController(),
-        isStickyMode = ModelHelper.isStickySessionSupported(this.oAppComponent.getMetaModel());
-      if (!controller.viewState) {
-        throw new Error(`viewState controller extension not available for controller: ${controller.getMetadata().getName()}`);
+          skipMerge = false,
+          viewId: stateIdentifier = REPLACE_COMPLETE_APPSTATE
+        } = createAppParameters ?? {},
+        rootController = appComponent.getRootControl().getController();
+      if (!rootController.viewState) {
+        throw new Error(`viewState controller extension not available for controller: ${rootController.getMetadata().getName()}`);
       }
-      let innerAppState = await controller.viewState.retrieveViewState();
+
+      // In case, on load of FCL app we have multiple views(LR, OP, sub-OP...) and url has iAppState(1).
+      // The LR view loads with applied iAppState(1) and calls createAppState(example: onSearch event in LR) before OP is loaded.
+      // This creates iAppState(2) before iAppState(1) is applied to OP.
+      // So, we try to wait till the routing is complete.
+      await rootController.routingIsComplete();
+
+      // Get appState to update
+      let innerAppState = await rootController.viewState.retrieveViewState();
+      innerAppState = this._getInnerAppStateForView(innerAppState, stateIdentifier);
       if (skipMerge) {
         innerAppState = {
           ...innerAppState,
@@ -63,35 +181,7 @@ sap.ui.define(["sap/base/Log", "sap/base/util/deepEqual", "sap/fe/core/helpers/C
           }
         };
       }
-      const appStateData = {
-        appState: innerAppState
-      };
-      let appStateKey = null;
-      if (innerAppState && !deepEqual(this._mCurrentAppState, innerAppState)) {
-        this._mCurrentAppState = innerAppState;
-        try {
-          this.nbSimultaneousCreateRequest++;
-          appStateKey = await navigationService.storeInnerAppStateAsync(appStateData, true, true);
-          Log.info("APPSTATE: Appstate stored");
-          if (replaceHash === true) {
-            const sNewHash = navigationService.replaceInnerAppStateKey(hash, appStateKey);
-            this.nbSimultaneousCreateRequest--;
-            if (this.nbSimultaneousCreateRequest === 0 && sNewHash !== hash) {
-              routerProxy.navToHash(sNewHash, undefined, undefined, undefined, !isStickyMode);
-              this.bNoRouteChange = true;
-            }
-            Log.info("APPSTATE: navToHash");
-          }
-        } catch (oError) {
-          Log.error(oError);
-        }
-      } else {
-        appStateKey = routerProxy.findAppStateInHash(hash);
-      }
-      return {
-        appStateData: appStateData,
-        appStateKey: appStateKey
-      };
+      return this._getAppStateInfo(innerAppState, createAppParameters);
     };
     _proto._createNavigationParameters = function _createNavigationParameters(oAppData, sNavType) {
       return Object.assign({}, oAppData, {
@@ -182,7 +272,10 @@ sap.ui.define(["sap/base/Log", "sap/base/util/deepEqual", "sap/fe/core/helpers/C
         const appStateData = this._getAppStateData(oAppData, viewId, sNavType);
         // fetch the skipMerge flag from appState for save as tile
         const skipMerge = oAppData === null || oAppData === void 0 ? void 0 : (_oAppData$appState = oAppData.appState) === null || _oAppData$appState === void 0 ? void 0 : _oAppData$appState[SKIP_MERGE_KEY];
-        this._mCurrentAppState = sNavType === NavType.iAppState || sNavType === NavType.hybrid ? appStateData : undefined;
+        this._mCurrentAppState = sNavType === NavType.iAppState || sNavType === NavType.hybrid ? {
+          ...this._mCurrentAppState,
+          ...appStateData
+        } : {};
         let shouldApplyState = true;
         if (!oRootController.viewState) {
           throw new Error(`viewState extension required for controller ${oRootController.getMetadata().getName()}`);
@@ -232,4 +325,4 @@ sap.ui.define(["sap/base/Log", "sap/base/util/deepEqual", "sap/fe/core/helpers/C
    */
   return AppStateHandler;
 }, true);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["NavType","library","SKIP_MERGE_KEY","AppStateHandler","defineUI5Class","oAppComponent","_mCurrentAppState","sId","getId","nbSimultaneousCreateRequest","bNoRouteChange","Log","info","createAppState","createAppParameters","getEnvironmentCapabilities","getCapabilities","AppState","BusyLocker","isLocked","replaceHash","skipMerge","navigationService","getNavigationService","routerProxy","getRouterProxy","hash","getHash","controller","getRootControl","getController","isStickyMode","ModelHelper","isStickySessionSupported","getMetaModel","viewState","Error","getMetadata","getName","innerAppState","retrieveViewState","appStateData","appState","appStateKey","deepEqual","storeInnerAppStateAsync","sNewHash","replaceInnerAppStateKey","navToHash","undefined","oError","error","findAppStateInHash","_createNavigationParameters","oAppData","sNavType","Object","assign","selectionVariantDefaults","oDefaultedSelectionVariant","selectionVariant","oSelectionVariant","requiresStandardVariant","bNavSelVarHasDefaultsOnly","navigationType","_checkIfLastSeenRecord","view","internalModelContext","getBindingContext","getProperty","technicalKeysObject","bindingContext","path","getPath","metaModel","getModel","metaPath","getMetaPath","technicalKeys","getObject","element","keyValue","setProperty","_getAppStateData","viewId","navType","key","i","hybrid","iAppState","keys","length","applyAppState","Promise","resolve","checkIfLastSeenRecord","lock","oNavigationService","toES6Promise","parseNavigation","catch","aErrorData","warning","then","aResults","initial","oRootController","shouldApplyState","_isStateEmptyForIAppStateNavType","_getInitialStateApplied","_setInitialStateApplied","applyViewState","finally","unlock","checkIfRouteChangedByIApp","resetRouteChangedByIApp","BaseObject"],"sourceRoot":".","sources":["AppStateHandler.ts"],"sourcesContent":["import Log from \"sap/base/Log\";\nimport deepEqual from \"sap/base/util/deepEqual\";\nimport type AppComponent from \"sap/fe/core/AppComponent\";\nimport type { NavigationParameter } from \"sap/fe/core/controllerextensions/ViewState\";\nimport { defineUI5Class } from \"sap/fe/core/helpers/ClassSupport\";\nimport type { InternalModelContext } from \"sap/fe/core/helpers/ModelHelper\";\nimport toES6Promise from \"sap/fe/core/helpers/ToES6Promise\";\nimport type { SelectionVariant } from \"sap/fe/navigation/SelectionVariant\";\nimport library from \"sap/fe/navigation/library\";\nimport BaseObject from \"sap/ui/base/Object\";\nimport type View from \"sap/ui/core/mvc/View\";\nimport type Context from \"sap/ui/model/odata/v4/Context\";\nimport BusyLocker from \"./controllerextensions/BusyLocker\";\nimport ModelHelper from \"./helpers/ModelHelper\";\n\nconst NavType = library.NavType;\ntype AppState = {\n\tskipMerge?: boolean;\n\t[key: string]: unknown;\n};\nexport type AppData = {\n\toDefaultedSelectionVariant: SelectionVariant;\n\toSelectionVariant: SelectionVariant;\n\tbNavSelVarHasDefaultsOnly: boolean;\n\tappState: AppState;\n\tiAppState?: {\n\t\tappState: AppState;\n\t};\n};\nconst SKIP_MERGE_KEY = \"skipMerge\";\nexport type IAppState = {\n\tappState: Record<string, unknown>;\n};\n\nexport type AppDataInfo = {\n\tappStateData: { appState: object | undefined };\n\tappStateKey: string | null;\n};\n\n@defineUI5Class(\"sap.fe.core.AppStateHandler\")\nclass AppStateHandler extends BaseObject {\n\tpublic sId: string;\n\n\tpublic oAppComponent: AppComponent;\n\n\tpublic bNoRouteChange: boolean;\n\n\tprivate _mCurrentAppState?: AppState = {};\n\n\tnbSimultaneousCreateRequest: number;\n\n\tconstructor(oAppComponent: AppComponent) {\n\t\tsuper();\n\t\tthis.oAppComponent = oAppComponent;\n\t\tthis.sId = `${oAppComponent.getId()}/AppStateHandler`;\n\t\tthis.nbSimultaneousCreateRequest = 0;\n\t\tthis.bNoRouteChange = false;\n\t\tLog.info(\"APPSTATE : Appstate handler initialized\");\n\t}\n\n\tgetId() {\n\t\treturn this.sId;\n\t}\n\n\t/**\n\t * Creates or updates the appstate.\n\t * Replaces the hash with the new appstate based on replaceHash\n\t *\n\t * @param createAppParameters Parameters for creating new appstate\n\t * @param createAppParameters.replaceHash Boolean which determines to replace the hash with the new generated key\n\t * @param createAppParameters.skipMerge Boolean which determines to skip the key user shine through\n\t * @returns A promise resolving the stored data or appstate key based on returnKey property\n\t */\n\tasync createAppState(createAppParameters?: { replaceHash?: boolean; skipMerge?: boolean }): Promise<void | AppDataInfo> {\n\t\tif (!this.oAppComponent.getEnvironmentCapabilities().getCapabilities().AppState || BusyLocker.isLocked(this)) {\n\t\t\treturn;\n\t\t}\n\t\tconst { replaceHash = true, skipMerge = false } = createAppParameters || {};\n\n\t\tconst navigationService = this.oAppComponent.getNavigationService(),\n\t\t\trouterProxy = this.oAppComponent.getRouterProxy(),\n\t\t\thash = routerProxy.getHash(),\n\t\t\tcontroller = this.oAppComponent.getRootControl().getController(),\n\t\t\tisStickyMode = ModelHelper.isStickySessionSupported(this.oAppComponent.getMetaModel());\n\n\t\tif (!controller.viewState) {\n\t\t\tthrow new Error(`viewState controller extension not available for controller: ${controller.getMetadata().getName()}`);\n\t\t}\n\t\tlet innerAppState = await controller.viewState.retrieveViewState();\n\t\tif (skipMerge) {\n\t\t\tinnerAppState = { ...innerAppState, ...{ skipMerge } };\n\t\t}\n\t\tconst appStateData = { appState: innerAppState };\n\t\tlet appStateKey: string | null = null;\n\t\tif (innerAppState && !deepEqual(this._mCurrentAppState, innerAppState)) {\n\t\t\tthis._mCurrentAppState = innerAppState as Record<string, unknown>;\n\t\t\ttry {\n\t\t\t\tthis.nbSimultaneousCreateRequest++;\n\t\t\t\tappStateKey = await navigationService.storeInnerAppStateAsync(appStateData, true, true);\n\t\t\t\tLog.info(\"APPSTATE: Appstate stored\");\n\t\t\t\tif (replaceHash === true) {\n\t\t\t\t\tconst sNewHash = navigationService.replaceInnerAppStateKey(hash, appStateKey);\n\t\t\t\t\tthis.nbSimultaneousCreateRequest--;\n\t\t\t\t\tif (this.nbSimultaneousCreateRequest === 0 && sNewHash !== hash) {\n\t\t\t\t\t\trouterProxy.navToHash(sNewHash, undefined, undefined, undefined, !isStickyMode);\n\t\t\t\t\t\tthis.bNoRouteChange = true;\n\t\t\t\t\t}\n\t\t\t\t\tLog.info(\"APPSTATE: navToHash\");\n\t\t\t\t}\n\t\t\t} catch (oError: unknown) {\n\t\t\t\tLog.error(oError as string);\n\t\t\t}\n\t\t} else {\n\t\t\tappStateKey = routerProxy.findAppStateInHash(hash) as string;\n\t\t}\n\t\treturn {\n\t\t\tappStateData: appStateData,\n\t\t\tappStateKey: appStateKey\n\t\t};\n\t}\n\n\t_createNavigationParameters(oAppData: AppData, sNavType: string): NavigationParameter {\n\t\treturn Object.assign({}, oAppData, {\n\t\t\tselectionVariantDefaults: oAppData.oDefaultedSelectionVariant,\n\t\t\tselectionVariant: oAppData.oSelectionVariant,\n\t\t\trequiresStandardVariant: !oAppData.bNavSelVarHasDefaultsOnly,\n\t\t\tnavigationType: sNavType\n\t\t});\n\t}\n\n\t_checkIfLastSeenRecord(view?: View) {\n\t\t//getting the internal model context in order to fetch the technicalkeys of last seen record and close column flag set in the internalrouting for retaining settings in persistence mode\n\t\tconst internalModelContext = view && (view.getBindingContext(\"internal\") as InternalModelContext);\n\t\tif (internalModelContext && internalModelContext.getProperty(\"fclColumnClosed\") === true) {\n\t\t\tconst technicalKeysObject = internalModelContext.getProperty(\"technicalKeysOfLastSeenRecord\");\n\t\t\tconst bindingContext = view?.getBindingContext() as Context;\n\t\t\tconst path = (bindingContext && bindingContext.getPath()) || \"\";\n\t\t\tconst metaModel = bindingContext?.getModel().getMetaModel();\n\t\t\tconst metaPath = metaModel?.getMetaPath(path);\n\t\t\tconst technicalKeys = metaModel?.getObject(`${metaPath}/$Type/$Key`);\n\t\t\tfor (const element of technicalKeys) {\n\t\t\t\tconst keyValue = bindingContext.getObject()[element];\n\t\t\t\tif (keyValue !== technicalKeysObject[element]) {\n\t\t\t\t\tinternalModelContext.setProperty(\"fclColumnClosed\", false);\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t\t//the record opened is not the last seen one : no need to persist the changes, reset to default instead\n\t\t}\n\t\treturn false;\n\t}\n\n\t_getAppStateData(oAppData: AppData, viewId?: string, navType?: string) {\n\t\tlet key = \"\",\n\t\t\ti = 0;\n\t\tconst appStateData = navType === NavType.hybrid ? oAppData.iAppState : oAppData;\n\n\t\tif (appStateData?.appState) {\n\t\t\tfor (i; i < Object.keys(appStateData.appState).length; i++) {\n\t\t\t\tif (Object.keys(appStateData.appState)[i] === viewId) {\n\t\t\t\t\tkey = Object.keys(appStateData.appState)[i];\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (appStateData?.appState) {\n\t\t\treturn {\n\t\t\t\t[Object.keys(appStateData.appState)[i]]: appStateData.appState[key] || {}\n\t\t\t};\n\t\t}\n\t}\n\n\t/**\n\t * Applies an appstate by fetching appdata and passing it to _applyAppstateToPage.\n\t *\n\t * @param viewId\n\t * @param view\n\t * @returns A promise for async handling\n\t */\n\tasync applyAppState(viewId?: string, view?: View) {\n\t\tif (!this.oAppComponent.getEnvironmentCapabilities().getCapabilities().AppState || BusyLocker.isLocked(this)) {\n\t\t\treturn Promise.resolve();\n\t\t}\n\n\t\tconst checkIfLastSeenRecord = this._checkIfLastSeenRecord(view);\n\t\tif (checkIfLastSeenRecord === true) {\n\t\t\treturn Promise.resolve();\n\t\t}\n\n\t\tBusyLocker.lock(this);\n\t\t// Done for busy indicator\n\t\tBusyLocker.lock(this.oAppComponent.getRootControl());\n\t\tconst oNavigationService = this.oAppComponent.getNavigationService();\n\t\t// TODO oNavigationService.parseNavigation() should return ES6 promise instead jQuery.promise\n\t\treturn toES6Promise(oNavigationService.parseNavigation())\n\t\t\t.catch(function (aErrorData: unknown[]) {\n\t\t\t\tif (!aErrorData) {\n\t\t\t\t\taErrorData = [];\n\t\t\t\t}\n\t\t\t\tLog.warning(\"APPSTATE: Parse Navigation failed\", aErrorData[0] as string);\n\t\t\t\treturn [\n\t\t\t\t\t{\n\t\t\t\t\t\t/* app data */\n\t\t\t\t\t},\n\t\t\t\t\taErrorData[1],\n\t\t\t\t\taErrorData[2]\n\t\t\t\t];\n\t\t\t})\n\t\t\t.then(async (aResults: unknown[]) => {\n\t\t\t\tLog.info(\"APPSTATE: Parse Navigation done\");\n\n\t\t\t\t// aResults[1] => oStartupParameters (not evaluated)\n\t\t\t\tconst oAppData = (aResults[0] || {}) as AppData,\n\t\t\t\t\tsNavType = (aResults[2] as string) || NavType.initial,\n\t\t\t\t\toRootController = this.oAppComponent.getRootControl().getController();\n\t\t\t\t// apply the appstate depending upon the view (LR/OP)\n\t\t\t\tconst appStateData = this._getAppStateData(oAppData, viewId, sNavType);\n\t\t\t\t// fetch the skipMerge flag from appState for save as tile\n\t\t\t\tconst skipMerge: boolean | undefined = oAppData?.appState?.[SKIP_MERGE_KEY];\n\t\t\t\tthis._mCurrentAppState = sNavType === NavType.iAppState || sNavType === NavType.hybrid ? appStateData : undefined;\n\t\t\t\tlet shouldApplyState = true;\n\n\t\t\t\tif (!oRootController.viewState) {\n\t\t\t\t\tthrow new Error(`viewState extension required for controller ${oRootController.getMetadata().getName()}`);\n\t\t\t\t}\n\t\t\t\tif (oRootController.viewState._isStateEmptyForIAppStateNavType(oAppData, sNavType)) {\n\t\t\t\t\tif (!oRootController.viewState._getInitialStateApplied()) {\n\t\t\t\t\t\toRootController.viewState._setInitialStateApplied();\n\t\t\t\t\t}\n\t\t\t\t\tshouldApplyState = false;\n\t\t\t\t}\n\t\t\t\tconst applyViewState = await oRootController.viewState.applyViewState(\n\t\t\t\t\tthis._mCurrentAppState as Record<string, unknown>,\n\t\t\t\t\tthis._createNavigationParameters(oAppData, sNavType),\n\t\t\t\t\tskipMerge\n\t\t\t\t);\n\t\t\t\tif (!shouldApplyState) {\n\t\t\t\t\treturn {};\n\t\t\t\t} else {\n\t\t\t\t\treturn applyViewState;\n\t\t\t\t}\n\t\t\t})\n\t\t\t.catch(function (oError: unknown) {\n\t\t\t\tLog.error(\"appState could not be applied\", oError as string);\n\t\t\t\tthrow oError;\n\t\t\t})\n\t\t\t.finally(() => {\n\t\t\t\tBusyLocker.unlock(this);\n\t\t\t\tBusyLocker.unlock(this.oAppComponent.getRootControl());\n\t\t\t});\n\t}\n\n\t/**\n\t * To check is route is changed by change in the iAPPState.\n\t *\n\t * @returns `true` if the route has chnaged\n\t */\n\tcheckIfRouteChangedByIApp() {\n\t\treturn this.bNoRouteChange;\n\t}\n\n\t/**\n\t * Reset the route changed by iAPPState.\n\t */\n\tresetRouteChangedByIApp() {\n\t\tif (this.bNoRouteChange) {\n\t\t\tthis.bNoRouteChange = false;\n\t\t}\n\t}\n}\n\n/**\n * @global\n */\nexport default AppStateHandler;\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["NavType","library","SKIP_MERGE_KEY","REPLACE_COMPLETE_APPSTATE","AppStateHandler","defineUI5Class","oAppComponent","_mCurrentAppState","sId","getId","simultaneousCreateRequest","bNoRouteChange","Log","info","_getInnerAppStateForView","innerAppState","stateIdentifier","_addAppStateInHash","appStateKey","appComponent","navigationService","getNavigationService","routerProxy","getRouterProxy","hash","getHash","isStickyMode","ModelHelper","isStickySessionSupported","getMetaModel","newHash","replaceInnerAppStateKey","getFullHash","navToHash","undefined","_createAppStateKey","appStateData","storeInnerAppStateAsync","_getAppStateInfo","createAppParameters","replaceHash","viewId","appState","currentStateToUpdate","deepEqual","oError","error","findAppStateInHash","createAppState","getEnvironmentCapabilities","getCapabilities","AppState","BusyLocker","isLocked","skipMerge","rootController","getRootControl","getController","viewState","Error","getMetadata","getName","routingIsComplete","retrieveViewState","_createNavigationParameters","oAppData","sNavType","Object","assign","selectionVariantDefaults","oDefaultedSelectionVariant","selectionVariant","oSelectionVariant","requiresStandardVariant","bNavSelVarHasDefaultsOnly","navigationType","_checkIfLastSeenRecord","view","internalModelContext","getBindingContext","getProperty","technicalKeysObject","bindingContext","path","getPath","metaModel","getModel","metaPath","getMetaPath","technicalKeys","getObject","element","keyValue","setProperty","_getAppStateData","navType","key","i","hybrid","iAppState","keys","length","applyAppState","Promise","resolve","checkIfLastSeenRecord","lock","oNavigationService","toES6Promise","parseNavigation","catch","aErrorData","warning","then","aResults","initial","oRootController","shouldApplyState","_isStateEmptyForIAppStateNavType","_getInitialStateApplied","_setInitialStateApplied","applyViewState","finally","unlock","checkIfRouteChangedByIApp","resetRouteChangedByIApp","BaseObject"],"sourceRoot":".","sources":["AppStateHandler.ts"],"sourcesContent":["import Log from \"sap/base/Log\";\nimport deepEqual from \"sap/base/util/deepEqual\";\nimport type AppComponent from \"sap/fe/core/AppComponent\";\nimport type { NavigationParameter } from \"sap/fe/core/controllerextensions/ViewState\";\nimport { defineUI5Class } from \"sap/fe/core/helpers/ClassSupport\";\nimport type { InternalModelContext } from \"sap/fe/core/helpers/ModelHelper\";\nimport toES6Promise from \"sap/fe/core/helpers/ToES6Promise\";\nimport type { InnerAppData } from \"sap/fe/navigation/NavigationHandler\";\nimport type { SelectionVariant } from \"sap/fe/navigation/SelectionVariant\";\nimport library from \"sap/fe/navigation/library\";\nimport BaseObject from \"sap/ui/base/Object\";\nimport type View from \"sap/ui/core/mvc/View\";\nimport type Context from \"sap/ui/model/odata/v4/Context\";\nimport BusyLocker from \"./controllerextensions/BusyLocker\";\nimport ModelHelper from \"./helpers/ModelHelper\";\n\nconst NavType = library.NavType;\ntype AppState = {\n\tskipMerge?: boolean;\n\t[key: string]: unknown;\n};\nexport type AppData = {\n\toDefaultedSelectionVariant: SelectionVariant;\n\toSelectionVariant: SelectionVariant;\n\tbNavSelVarHasDefaultsOnly: boolean;\n\tappState: AppState;\n\tiAppState?: {\n\t\tappState: AppState;\n\t};\n};\nconst SKIP_MERGE_KEY = \"skipMerge\";\nexport type IAppState = {\n\tappState: Record<string, unknown>;\n};\n\nexport type AppDataInfo = {\n\tappStateData: { appState: object | undefined };\n\tappStateKey: string | null;\n};\n\nexport type CreateAppParameters = {\n\treplaceHash?: boolean;\n\tskipMerge?: boolean;\n\tviewId?: string;\n};\n\nconst REPLACE_COMPLETE_APPSTATE = \"REPLACE_COMPLETE_APPSTATE\";\n\n@defineUI5Class(\"sap.fe.core.AppStateHandler\")\nclass AppStateHandler extends BaseObject {\n\tpublic sId: string;\n\n\tpublic oAppComponent: AppComponent;\n\n\tpublic bNoRouteChange: boolean;\n\n\tprivate _mCurrentAppState?: AppState = {};\n\n\tsimultaneousCreateRequest: Record<string, number>;\n\n\tconstructor(oAppComponent: AppComponent) {\n\t\tsuper();\n\t\tthis.oAppComponent = oAppComponent;\n\t\tthis.sId = `${oAppComponent.getId()}/AppStateHandler`;\n\t\tthis.simultaneousCreateRequest = {};\n\t\tthis.bNoRouteChange = false;\n\t\tLog.info(\"APPSTATE : Appstate handler initialized\");\n\t}\n\n\tgetId() {\n\t\treturn this.sId;\n\t}\n\n\t/**\n\t * Get the view-specific appstate.\n\t *\n\t * @param innerAppState Overall appstate\n\t * @param stateIdentifier State identifier, id of the local view\n\t * @returns Inner appstate\n\t */\n\t_getInnerAppStateForView(innerAppState: InnerAppData | undefined, stateIdentifier: string): InnerAppData | undefined {\n\t\tif (stateIdentifier === REPLACE_COMPLETE_APPSTATE || !innerAppState) {\n\t\t\t// overall app state needs to be considered.\n\t\t\treturn innerAppState;\n\t\t}\n\n\t\t// we take the subset of the app state wrt to the local view id.\n\t\treturn {\n\t\t\t[stateIdentifier]: innerAppState[stateIdentifier as keyof typeof innerAppState] || {}\n\t\t};\n\t}\n\n\t/**\n\t * Add appstate in hash.\n\t *\n\t * @param appStateKey Appstate key\n\t * @param stateIdentifier State identifier, Id of the local view\n\t */\n\t_addAppStateInHash(appStateKey: string, stateIdentifier: string): void {\n\t\tconst appComponent = this.oAppComponent,\n\t\t\tnavigationService = appComponent.getNavigationService(),\n\t\t\trouterProxy = appComponent.getRouterProxy(),\n\t\t\thash = routerProxy.getHash(),\n\t\t\tisStickyMode = ModelHelper.isStickySessionSupported(appComponent.getMetaModel()),\n\t\t\tnewHash = navigationService.replaceInnerAppStateKey(routerProxy.getFullHash(), appStateKey);\n\n\t\tif (this.simultaneousCreateRequest[stateIdentifier] === 0 && newHash !== hash) {\n\t\t\trouterProxy.navToHash(newHash, undefined, undefined, undefined, !isStickyMode);\n\t\t\tthis.bNoRouteChange = true;\n\t\t}\n\t\tLog.info(\"APPSTATE: navToHash\");\n\t}\n\n\t/**\n\t * Create Appstate Key.\n\t *\n\t * @param appStateData Appstate\n\t * @param stateIdentifier State identifier, Id of the local view\n\t * @returns Appstate Key\n\t */\n\tasync _createAppStateKey(appStateData: InnerAppData, stateIdentifier: string): Promise<string> {\n\t\tconst appComponent = this.oAppComponent,\n\t\t\tnavigationService = appComponent.getNavigationService();\n\n\t\tif (this.simultaneousCreateRequest[stateIdentifier]) {\n\t\t\t// any other value\n\t\t\tthis.simultaneousCreateRequest[stateIdentifier]++;\n\t\t} else {\n\t\t\t// 0 or undefined\n\t\t\tthis.simultaneousCreateRequest[stateIdentifier] = 1;\n\t\t}\n\n\t\tconst appStateKey = await navigationService.storeInnerAppStateAsync(appStateData, true, true);\n\n\t\tthis.simultaneousCreateRequest[stateIdentifier]--;\n\n\t\tLog.info(\"APPSTATE: Appstate stored\");\n\t\treturn appStateKey;\n\t}\n\n\t/**\n\t * Creates appstate info.\n\t *\n\t * @param innerAppState\n\t * @param createAppParameters Parameters for creating a new appstate\n\t * @param createAppParameters.replaceHash A Boolean that determines whether to replace the hash with the newly generated key\n\t * @param createAppParameters.viewId Id of the view for which we need to create the app state. This allows us to create or update view-specific appstate.\n\t * @returns A promise that resolves the stored data or appstate keys\n\t */\n\tasync _getAppStateInfo(innerAppState: InnerAppData | undefined, createAppParameters?: CreateAppParameters): Promise<AppDataInfo> {\n\t\tconst appComponent = this.oAppComponent;\n\t\tconst { replaceHash = true, viewId: stateIdentifier = REPLACE_COMPLETE_APPSTATE } = createAppParameters ?? {};\n\n\t\tlet appStateKey: string | null = null;\n\t\tlet appStateData = { appState: this._mCurrentAppState };\n\n\t\tconst currentStateToUpdate = this._getInnerAppStateForView(this._mCurrentAppState, stateIdentifier);\n\t\tif (innerAppState && !deepEqual(currentStateToUpdate, innerAppState)) {\n\t\t\t//\n\t\t\tthis._mCurrentAppState = { ...this._mCurrentAppState, ...(innerAppState as Record<string, unknown>) };\n\t\t\tappStateData = { appState: this._mCurrentAppState };\n\t\t\ttry {\n\t\t\t\tappStateKey = await this._createAppStateKey(appStateData, stateIdentifier);\n\t\t\t\tif (replaceHash === true) {\n\t\t\t\t\tthis._addAppStateInHash(appStateKey, stateIdentifier);\n\t\t\t\t}\n\t\t\t} catch (oError: unknown) {\n\t\t\t\tLog.error(oError as string);\n\t\t\t}\n\t\t} else {\n\t\t\tconst routerProxy = appComponent.getRouterProxy(),\n\t\t\t\thash = routerProxy.getHash();\n\t\t\tappStateKey = routerProxy.findAppStateInHash(hash) as string;\n\t\t}\n\t\treturn {\n\t\t\tappStateData,\n\t\t\tappStateKey\n\t\t};\n\t}\n\n\t/**\n\t * Creates or updates the appstate.\n\t * Replaces the hash with the new appstate based on replaceHash\n\t *\n\t * @param createAppParameters Parameters for creating new appstate\n\t * @param createAppParameters.replaceHash Boolean which determines to replace the hash with the new generated key\n\t * @param createAppParameters.skipMerge Boolean which determines to skip the key user shine through\n\t * @param createAppParameters.viewId Id of the view for which we need to create the app state. This allows us to create or update view-specific appstate.\n\t * @returns A promise resolving the stored data or appstate key\n\t */\n\tasync createAppState(createAppParameters?: CreateAppParameters): Promise<void | AppDataInfo> {\n\t\tconst appComponent = this.oAppComponent;\n\t\tif (!appComponent.getEnvironmentCapabilities().getCapabilities().AppState || BusyLocker.isLocked(this)) {\n\t\t\treturn;\n\t\t}\n\t\tconst { skipMerge = false, viewId: stateIdentifier = REPLACE_COMPLETE_APPSTATE } = createAppParameters ?? {},\n\t\t\trootController = appComponent.getRootControl().getController();\n\n\t\tif (!rootController.viewState) {\n\t\t\tthrow new Error(`viewState controller extension not available for controller: ${rootController.getMetadata().getName()}`);\n\t\t}\n\n\t\t// In case, on load of FCL app we have multiple views(LR, OP, sub-OP...) and url has iAppState(1).\n\t\t// The LR view loads with applied iAppState(1) and calls createAppState(example: onSearch event in LR) before OP is loaded.\n\t\t// This creates iAppState(2) before iAppState(1) is applied to OP.\n\t\t// So, we try to wait till the routing is complete.\n\t\tawait rootController.routingIsComplete();\n\n\t\t// Get appState to update\n\t\tlet innerAppState = (await rootController.viewState.retrieveViewState()) as InnerAppData | undefined;\n\t\tinnerAppState = this._getInnerAppStateForView(innerAppState, stateIdentifier);\n\t\tif (skipMerge) {\n\t\t\tinnerAppState = { ...innerAppState, ...{ skipMerge } };\n\t\t}\n\n\t\treturn this._getAppStateInfo(innerAppState, createAppParameters);\n\t}\n\n\t_createNavigationParameters(oAppData: AppData, sNavType: string): NavigationParameter {\n\t\treturn Object.assign({}, oAppData, {\n\t\t\tselectionVariantDefaults: oAppData.oDefaultedSelectionVariant,\n\t\t\tselectionVariant: oAppData.oSelectionVariant,\n\t\t\trequiresStandardVariant: !oAppData.bNavSelVarHasDefaultsOnly,\n\t\t\tnavigationType: sNavType\n\t\t});\n\t}\n\n\t_checkIfLastSeenRecord(view?: View) {\n\t\t//getting the internal model context in order to fetch the technicalkeys of last seen record and close column flag set in the internalrouting for retaining settings in persistence mode\n\t\tconst internalModelContext = view && (view.getBindingContext(\"internal\") as InternalModelContext);\n\t\tif (internalModelContext && internalModelContext.getProperty(\"fclColumnClosed\") === true) {\n\t\t\tconst technicalKeysObject = internalModelContext.getProperty(\"technicalKeysOfLastSeenRecord\");\n\t\t\tconst bindingContext = view?.getBindingContext() as Context;\n\t\t\tconst path = (bindingContext && bindingContext.getPath()) || \"\";\n\t\t\tconst metaModel = bindingContext?.getModel().getMetaModel();\n\t\t\tconst metaPath = metaModel?.getMetaPath(path);\n\t\t\tconst technicalKeys = metaModel?.getObject(`${metaPath}/$Type/$Key`);\n\t\t\tfor (const element of technicalKeys) {\n\t\t\t\tconst keyValue = bindingContext.getObject()[element];\n\t\t\t\tif (keyValue !== technicalKeysObject[element]) {\n\t\t\t\t\tinternalModelContext.setProperty(\"fclColumnClosed\", false);\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t\t//the record opened is not the last seen one : no need to persist the changes, reset to default instead\n\t\t}\n\t\treturn false;\n\t}\n\n\t_getAppStateData(oAppData: AppData, viewId?: string, navType?: string) {\n\t\tlet key = \"\",\n\t\t\ti = 0;\n\t\tconst appStateData = navType === NavType.hybrid ? oAppData.iAppState : oAppData;\n\n\t\tif (appStateData?.appState) {\n\t\t\tfor (i; i < Object.keys(appStateData.appState).length; i++) {\n\t\t\t\tif (Object.keys(appStateData.appState)[i] === viewId) {\n\t\t\t\t\tkey = Object.keys(appStateData.appState)[i];\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (appStateData?.appState) {\n\t\t\treturn {\n\t\t\t\t[Object.keys(appStateData.appState)[i]]: appStateData.appState[key] || {}\n\t\t\t};\n\t\t}\n\t}\n\n\t/**\n\t * Applies an appstate by fetching appdata and passing it to _applyAppstateToPage.\n\t *\n\t * @param viewId\n\t * @param view\n\t * @returns A promise for async handling\n\t */\n\tasync applyAppState(viewId?: string, view?: View) {\n\t\tif (!this.oAppComponent.getEnvironmentCapabilities().getCapabilities().AppState || BusyLocker.isLocked(this)) {\n\t\t\treturn Promise.resolve();\n\t\t}\n\n\t\tconst checkIfLastSeenRecord = this._checkIfLastSeenRecord(view);\n\t\tif (checkIfLastSeenRecord === true) {\n\t\t\treturn Promise.resolve();\n\t\t}\n\n\t\tBusyLocker.lock(this);\n\t\t// Done for busy indicator\n\t\tBusyLocker.lock(this.oAppComponent.getRootControl());\n\t\tconst oNavigationService = this.oAppComponent.getNavigationService();\n\t\t// TODO oNavigationService.parseNavigation() should return ES6 promise instead jQuery.promise\n\t\treturn toES6Promise(oNavigationService.parseNavigation())\n\t\t\t.catch(function (aErrorData: unknown[]) {\n\t\t\t\tif (!aErrorData) {\n\t\t\t\t\taErrorData = [];\n\t\t\t\t}\n\t\t\t\tLog.warning(\"APPSTATE: Parse Navigation failed\", aErrorData[0] as string);\n\t\t\t\treturn [\n\t\t\t\t\t{\n\t\t\t\t\t\t/* app data */\n\t\t\t\t\t},\n\t\t\t\t\taErrorData[1],\n\t\t\t\t\taErrorData[2]\n\t\t\t\t];\n\t\t\t})\n\t\t\t.then(async (aResults: unknown[]) => {\n\t\t\t\tLog.info(\"APPSTATE: Parse Navigation done\");\n\n\t\t\t\t// aResults[1] => oStartupParameters (not evaluated)\n\t\t\t\tconst oAppData = (aResults[0] || {}) as AppData,\n\t\t\t\t\tsNavType = (aResults[2] as string) || NavType.initial,\n\t\t\t\t\toRootController = this.oAppComponent.getRootControl().getController();\n\t\t\t\t// apply the appstate depending upon the view (LR/OP)\n\t\t\t\tconst appStateData = this._getAppStateData(oAppData, viewId, sNavType);\n\t\t\t\t// fetch the skipMerge flag from appState for save as tile\n\t\t\t\tconst skipMerge: boolean | undefined = oAppData?.appState?.[SKIP_MERGE_KEY];\n\t\t\t\tthis._mCurrentAppState =\n\t\t\t\t\tsNavType === NavType.iAppState || sNavType === NavType.hybrid ? { ...this._mCurrentAppState, ...appStateData } : {};\n\t\t\t\tlet shouldApplyState = true;\n\t\t\t\tif (!oRootController.viewState) {\n\t\t\t\t\tthrow new Error(`viewState extension required for controller ${oRootController.getMetadata().getName()}`);\n\t\t\t\t}\n\t\t\t\tif (oRootController.viewState._isStateEmptyForIAppStateNavType(oAppData, sNavType)) {\n\t\t\t\t\tif (!oRootController.viewState._getInitialStateApplied()) {\n\t\t\t\t\t\toRootController.viewState._setInitialStateApplied();\n\t\t\t\t\t}\n\t\t\t\t\tshouldApplyState = false;\n\t\t\t\t}\n\t\t\t\tconst applyViewState = await oRootController.viewState.applyViewState(\n\t\t\t\t\tthis._mCurrentAppState as Record<string, unknown>,\n\t\t\t\t\tthis._createNavigationParameters(oAppData, sNavType),\n\t\t\t\t\tskipMerge\n\t\t\t\t);\n\t\t\t\tif (!shouldApplyState) {\n\t\t\t\t\treturn {};\n\t\t\t\t} else {\n\t\t\t\t\treturn applyViewState;\n\t\t\t\t}\n\t\t\t})\n\t\t\t.catch(function (oError: unknown) {\n\t\t\t\tLog.error(\"appState could not be applied\", oError as string);\n\t\t\t\tthrow oError;\n\t\t\t})\n\t\t\t.finally(() => {\n\t\t\t\tBusyLocker.unlock(this);\n\t\t\t\tBusyLocker.unlock(this.oAppComponent.getRootControl());\n\t\t\t});\n\t}\n\n\t/**\n\t * To check is route is changed by change in the iAPPState.\n\t *\n\t * @returns `true` if the route has chnaged\n\t */\n\tcheckIfRouteChangedByIApp() {\n\t\treturn this.bNoRouteChange;\n\t}\n\n\t/**\n\t * Reset the route changed by iAPPState.\n\t */\n\tresetRouteChangedByIApp() {\n\t\tif (this.bNoRouteChange) {\n\t\t\tthis.bNoRouteChange = false;\n\t\t}\n\t}\n}\n\n/**\n * @global\n */\nexport default AppStateHandler;\n"],"mappings":";AAAA;AAAA;AAAA;;;;;;;;EAgBA,MAAMA,OAAO,GAAGC,OAAO,CAACD,OAAO;EAc/B,MAAME,cAAc,GAAG,WAAW;EAgBlC,MAAMC,yBAAyB,GAAG,2BAA2B;EAAC,IAGxDC,eAAe,WADpBC,cAAc,CAAC,6BAA6B,CAAC;IAAA;IAY7C,yBAAYC,aAA2B,EAAE;MAAA;MACxC,8BAAO;MAAC,MALDC,iBAAiB,GAAc,CAAC,CAAC;MAMxC,MAAKD,aAAa,GAAGA,aAAa;MAClC,MAAKE,GAAG,GAAI,GAAEF,aAAa,CAACG,KAAK,EAAG,kBAAiB;MACrD,MAAKC,yBAAyB,GAAG,CAAC,CAAC;MACnC,MAAKC,cAAc,GAAG,KAAK;MAC3BC,GAAG,CAACC,IAAI,CAAC,yCAAyC,CAAC;MAAC;IACrD;IAAC;IAAA,OAEDJ,KAAK,GAAL,iBAAQ;MACP,OAAO,IAAI,CAACD,GAAG;IAChB;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA,OANC;IAAA,OAOAM,wBAAwB,GAAxB,kCAAyBC,aAAuC,EAAEC,eAAuB,EAA4B;MACpH,IAAIA,eAAe,KAAKb,yBAAyB,IAAI,CAACY,aAAa,EAAE;QACpE;QACA,OAAOA,aAAa;MACrB;;MAEA;MACA,OAAO;QACN,CAACC,eAAe,GAAGD,aAAa,CAACC,eAAe,CAA+B,IAAI,CAAC;MACrF,CAAC;IACF;;IAEA;AACD;AACA;AACA;AACA;AACA,OALC;IAAA,OAMAC,kBAAkB,GAAlB,4BAAmBC,WAAmB,EAAEF,eAAuB,EAAQ;MACtE,MAAMG,YAAY,GAAG,IAAI,CAACb,aAAa;QACtCc,iBAAiB,GAAGD,YAAY,CAACE,oBAAoB,EAAE;QACvDC,WAAW,GAAGH,YAAY,CAACI,cAAc,EAAE;QAC3CC,IAAI,GAAGF,WAAW,CAACG,OAAO,EAAE;QAC5BC,YAAY,GAAGC,WAAW,CAACC,wBAAwB,CAACT,YAAY,CAACU,YAAY,EAAE,CAAC;QAChFC,OAAO,GAAGV,iBAAiB,CAACW,uBAAuB,CAACT,WAAW,CAACU,WAAW,EAAE,EAAEd,WAAW,CAAC;MAE5F,IAAI,IAAI,CAACR,yBAAyB,CAACM,eAAe,CAAC,KAAK,CAAC,IAAIc,OAAO,KAAKN,IAAI,EAAE;QAC9EF,WAAW,CAACW,SAAS,CAACH,OAAO,EAAEI,SAAS,EAAEA,SAAS,EAAEA,SAAS,EAAE,CAACR,YAAY,CAAC;QAC9E,IAAI,CAACf,cAAc,GAAG,IAAI;MAC3B;MACAC,GAAG,CAACC,IAAI,CAAC,qBAAqB,CAAC;IAChC;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA,OANC;IAAA,OAOMsB,kBAAkB,GAAxB,kCAAyBC,YAA0B,EAAEpB,eAAuB,EAAmB;MAC9F,MAAMG,YAAY,GAAG,IAAI,CAACb,aAAa;QACtCc,iBAAiB,GAAGD,YAAY,CAACE,oBAAoB,EAAE;MAExD,IAAI,IAAI,CAACX,yBAAyB,CAACM,eAAe,CAAC,EAAE;QACpD;QACA,IAAI,CAACN,yBAAyB,CAACM,eAAe,CAAC,EAAE;MAClD,CAAC,MAAM;QACN;QACA,IAAI,CAACN,yBAAyB,CAACM,eAAe,CAAC,GAAG,CAAC;MACpD;MAEA,MAAME,WAAW,GAAG,MAAME,iBAAiB,CAACiB,uBAAuB,CAACD,YAAY,EAAE,IAAI,EAAE,IAAI,CAAC;MAE7F,IAAI,CAAC1B,yBAAyB,CAACM,eAAe,CAAC,EAAE;MAEjDJ,GAAG,CAACC,IAAI,CAAC,2BAA2B,CAAC;MACrC,OAAOK,WAAW;IACnB;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OARC;IAAA,OASMoB,gBAAgB,GAAtB,gCAAuBvB,aAAuC,EAAEwB,mBAAyC,EAAwB;MAChI,MAAMpB,YAAY,GAAG,IAAI,CAACb,aAAa;MACvC,MAAM;QAAEkC,WAAW,GAAG,IAAI;QAAEC,MAAM,EAAEzB,eAAe,GAAGb;MAA0B,CAAC,GAAGoC,mBAAmB,IAAI,CAAC,CAAC;MAE7G,IAAIrB,WAA0B,GAAG,IAAI;MACrC,IAAIkB,YAAY,GAAG;QAAEM,QAAQ,EAAE,IAAI,CAACnC;MAAkB,CAAC;MAEvD,MAAMoC,oBAAoB,GAAG,IAAI,CAAC7B,wBAAwB,CAAC,IAAI,CAACP,iBAAiB,EAAES,eAAe,CAAC;MACnG,IAAID,aAAa,IAAI,CAAC6B,SAAS,CAACD,oBAAoB,EAAE5B,aAAa,CAAC,EAAE;QACrE;QACA,IAAI,CAACR,iBAAiB,GAAG;UAAE,GAAG,IAAI,CAACA,iBAAiB;UAAE,GAAIQ;QAA0C,CAAC;QACrGqB,YAAY,GAAG;UAAEM,QAAQ,EAAE,IAAI,CAACnC;QAAkB,CAAC;QACnD,IAAI;UACHW,WAAW,GAAG,MAAM,IAAI,CAACiB,kBAAkB,CAACC,YAAY,EAAEpB,eAAe,CAAC;UAC1E,IAAIwB,WAAW,KAAK,IAAI,EAAE;YACzB,IAAI,CAACvB,kBAAkB,CAACC,WAAW,EAAEF,eAAe,CAAC;UACtD;QACD,CAAC,CAAC,OAAO6B,MAAe,EAAE;UACzBjC,GAAG,CAACkC,KAAK,CAACD,MAAM,CAAW;QAC5B;MACD,CAAC,MAAM;QACN,MAAMvB,WAAW,GAAGH,YAAY,CAACI,cAAc,EAAE;UAChDC,IAAI,GAAGF,WAAW,CAACG,OAAO,EAAE;QAC7BP,WAAW,GAAGI,WAAW,CAACyB,kBAAkB,CAACvB,IAAI,CAAW;MAC7D;MACA,OAAO;QACNY,YAAY;QACZlB;MACD,CAAC;IACF;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OATC;IAAA,OAUM8B,cAAc,GAApB,8BAAqBT,mBAAyC,EAA+B;MAC5F,MAAMpB,YAAY,GAAG,IAAI,CAACb,aAAa;MACvC,IAAI,CAACa,YAAY,CAAC8B,0BAA0B,EAAE,CAACC,eAAe,EAAE,CAACC,QAAQ,IAAIC,UAAU,CAACC,QAAQ,CAAC,IAAI,CAAC,EAAE;QACvG;MACD;MACA,MAAM;UAAEC,SAAS,GAAG,KAAK;UAAEb,MAAM,EAAEzB,eAAe,GAAGb;QAA0B,CAAC,GAAGoC,mBAAmB,IAAI,CAAC,CAAC;QAC3GgB,cAAc,GAAGpC,YAAY,CAACqC,cAAc,EAAE,CAACC,aAAa,EAAE;MAE/D,IAAI,CAACF,cAAc,CAACG,SAAS,EAAE;QAC9B,MAAM,IAAIC,KAAK,CAAE,gEAA+DJ,cAAc,CAACK,WAAW,EAAE,CAACC,OAAO,EAAG,EAAC,CAAC;MAC1H;;MAEA;MACA;MACA;MACA;MACA,MAAMN,cAAc,CAACO,iBAAiB,EAAE;;MAExC;MACA,IAAI/C,aAAa,GAAI,MAAMwC,cAAc,CAACG,SAAS,CAACK,iBAAiB,EAA+B;MACpGhD,aAAa,GAAG,IAAI,CAACD,wBAAwB,CAACC,aAAa,EAAEC,eAAe,CAAC;MAC7E,IAAIsC,SAAS,EAAE;QACdvC,aAAa,GAAG;UAAE,GAAGA,aAAa;UAAE,GAAG;YAAEuC;UAAU;QAAE,CAAC;MACvD;MAEA,OAAO,IAAI,CAAChB,gBAAgB,CAACvB,aAAa,EAAEwB,mBAAmB,CAAC;IACjE,CAAC;IAAA,OAEDyB,2BAA2B,GAA3B,qCAA4BC,QAAiB,EAAEC,QAAgB,EAAuB;MACrF,OAAOC,MAAM,CAACC,MAAM,CAAC,CAAC,CAAC,EAAEH,QAAQ,EAAE;QAClCI,wBAAwB,EAAEJ,QAAQ,CAACK,0BAA0B;QAC7DC,gBAAgB,EAAEN,QAAQ,CAACO,iBAAiB;QAC5CC,uBAAuB,EAAE,CAACR,QAAQ,CAACS,yBAAyB;QAC5DC,cAAc,EAAET;MACjB,CAAC,CAAC;IACH,CAAC;IAAA,OAEDU,sBAAsB,GAAtB,gCAAuBC,IAAW,EAAE;MACnC;MACA,MAAMC,oBAAoB,GAAGD,IAAI,IAAKA,IAAI,CAACE,iBAAiB,CAAC,UAAU,CAA0B;MACjG,IAAID,oBAAoB,IAAIA,oBAAoB,CAACE,WAAW,CAAC,iBAAiB,CAAC,KAAK,IAAI,EAAE;QACzF,MAAMC,mBAAmB,GAAGH,oBAAoB,CAACE,WAAW,CAAC,+BAA+B,CAAC;QAC7F,MAAME,cAAc,GAAGL,IAAI,aAAJA,IAAI,uBAAJA,IAAI,CAAEE,iBAAiB,EAAa;QAC3D,MAAMI,IAAI,GAAID,cAAc,IAAIA,cAAc,CAACE,OAAO,EAAE,IAAK,EAAE;QAC/D,MAAMC,SAAS,GAAGH,cAAc,aAAdA,cAAc,uBAAdA,cAAc,CAAEI,QAAQ,EAAE,CAACzD,YAAY,EAAE;QAC3D,MAAM0D,QAAQ,GAAGF,SAAS,aAATA,SAAS,uBAATA,SAAS,CAAEG,WAAW,CAACL,IAAI,CAAC;QAC7C,MAAMM,aAAa,GAAGJ,SAAS,aAATA,SAAS,uBAATA,SAAS,CAAEK,SAAS,CAAE,GAAEH,QAAS,aAAY,CAAC;QACpE,KAAK,MAAMI,OAAO,IAAIF,aAAa,EAAE;UACpC,MAAMG,QAAQ,GAAGV,cAAc,CAACQ,SAAS,EAAE,CAACC,OAAO,CAAC;UACpD,IAAIC,QAAQ,KAAKX,mBAAmB,CAACU,OAAO,CAAC,EAAE;YAC9Cb,oBAAoB,CAACe,WAAW,CAAC,iBAAiB,EAAE,KAAK,CAAC;YAC1D,OAAO,IAAI;UACZ;QACD;QACA;MACD;;MACA,OAAO,KAAK;IACb,CAAC;IAAA,OAEDC,gBAAgB,GAAhB,0BAAiB7B,QAAiB,EAAExB,MAAe,EAAEsD,OAAgB,EAAE;MACtE,IAAIC,GAAG,GAAG,EAAE;QACXC,CAAC,GAAG,CAAC;MACN,MAAM7D,YAAY,GAAG2D,OAAO,KAAK/F,OAAO,CAACkG,MAAM,GAAGjC,QAAQ,CAACkC,SAAS,GAAGlC,QAAQ;MAE/E,IAAI7B,YAAY,aAAZA,YAAY,eAAZA,YAAY,CAAEM,QAAQ,EAAE;QAC3B,KAAKuD,CAAC,EAAEA,CAAC,GAAG9B,MAAM,CAACiC,IAAI,CAAChE,YAAY,CAACM,QAAQ,CAAC,CAAC2D,MAAM,EAAEJ,CAAC,EAAE,EAAE;UAC3D,IAAI9B,MAAM,CAACiC,IAAI,CAAChE,YAAY,CAACM,QAAQ,CAAC,CAACuD,CAAC,CAAC,KAAKxD,MAAM,EAAE;YACrDuD,GAAG,GAAG7B,MAAM,CAACiC,IAAI,CAAChE,YAAY,CAACM,QAAQ,CAAC,CAACuD,CAAC,CAAC;YAC3C;UACD;QACD;MACD;MACA,IAAI7D,YAAY,aAAZA,YAAY,eAAZA,YAAY,CAAEM,QAAQ,EAAE;QAC3B,OAAO;UACN,CAACyB,MAAM,CAACiC,IAAI,CAAChE,YAAY,CAACM,QAAQ,CAAC,CAACuD,CAAC,CAAC,GAAG7D,YAAY,CAACM,QAAQ,CAACsD,GAAG,CAAC,IAAI,CAAC;QACzE,CAAC;MACF;IACD;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA,OANC;IAAA,OAOMM,aAAa,GAAnB,6BAAoB7D,MAAe,EAAEoC,IAAW,EAAE;MACjD,IAAI,CAAC,IAAI,CAACvE,aAAa,CAAC2C,0BAA0B,EAAE,CAACC,eAAe,EAAE,CAACC,QAAQ,IAAIC,UAAU,CAACC,QAAQ,CAAC,IAAI,CAAC,EAAE;QAC7G,OAAOkD,OAAO,CAACC,OAAO,EAAE;MACzB;MAEA,MAAMC,qBAAqB,GAAG,IAAI,CAAC7B,sBAAsB,CAACC,IAAI,CAAC;MAC/D,IAAI4B,qBAAqB,KAAK,IAAI,EAAE;QACnC,OAAOF,OAAO,CAACC,OAAO,EAAE;MACzB;MAEApD,UAAU,CAACsD,IAAI,CAAC,IAAI,CAAC;MACrB;MACAtD,UAAU,CAACsD,IAAI,CAAC,IAAI,CAACpG,aAAa,CAACkD,cAAc,EAAE,CAAC;MACpD,MAAMmD,kBAAkB,GAAG,IAAI,CAACrG,aAAa,CAACe,oBAAoB,EAAE;MACpE;MACA,OAAOuF,YAAY,CAACD,kBAAkB,CAACE,eAAe,EAAE,CAAC,CACvDC,KAAK,CAAC,UAAUC,UAAqB,EAAE;QACvC,IAAI,CAACA,UAAU,EAAE;UAChBA,UAAU,GAAG,EAAE;QAChB;QACAnG,GAAG,CAACoG,OAAO,CAAC,mCAAmC,EAAED,UAAU,CAAC,CAAC,CAAC,CAAW;QACzE,OAAO,CACN;UACC;QAAA,CACA,EACDA,UAAU,CAAC,CAAC,CAAC,EACbA,UAAU,CAAC,CAAC,CAAC,CACb;MACF,CAAC,CAAC,CACDE,IAAI,CAAC,MAAOC,QAAmB,IAAK;QAAA;QACpCtG,GAAG,CAACC,IAAI,CAAC,iCAAiC,CAAC;;QAE3C;QACA,MAAMoD,QAAQ,GAAIiD,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAa;UAC9ChD,QAAQ,GAAIgD,QAAQ,CAAC,CAAC,CAAC,IAAelH,OAAO,CAACmH,OAAO;UACrDC,eAAe,GAAG,IAAI,CAAC9G,aAAa,CAACkD,cAAc,EAAE,CAACC,aAAa,EAAE;QACtE;QACA,MAAMrB,YAAY,GAAG,IAAI,CAAC0D,gBAAgB,CAAC7B,QAAQ,EAAExB,MAAM,EAAEyB,QAAQ,CAAC;QACtE;QACA,MAAMZ,SAA8B,GAAGW,QAAQ,aAARA,QAAQ,6CAARA,QAAQ,CAAEvB,QAAQ,uDAAlB,mBAAqBxC,cAAc,CAAC;QAC3E,IAAI,CAACK,iBAAiB,GACrB2D,QAAQ,KAAKlE,OAAO,CAACmG,SAAS,IAAIjC,QAAQ,KAAKlE,OAAO,CAACkG,MAAM,GAAG;UAAE,GAAG,IAAI,CAAC3F,iBAAiB;UAAE,GAAG6B;QAAa,CAAC,GAAG,CAAC,CAAC;QACpH,IAAIiF,gBAAgB,GAAG,IAAI;QAC3B,IAAI,CAACD,eAAe,CAAC1D,SAAS,EAAE;UAC/B,MAAM,IAAIC,KAAK,CAAE,+CAA8CyD,eAAe,CAACxD,WAAW,EAAE,CAACC,OAAO,EAAG,EAAC,CAAC;QAC1G;QACA,IAAIuD,eAAe,CAAC1D,SAAS,CAAC4D,gCAAgC,CAACrD,QAAQ,EAAEC,QAAQ,CAAC,EAAE;UACnF,IAAI,CAACkD,eAAe,CAAC1D,SAAS,CAAC6D,uBAAuB,EAAE,EAAE;YACzDH,eAAe,CAAC1D,SAAS,CAAC8D,uBAAuB,EAAE;UACpD;UACAH,gBAAgB,GAAG,KAAK;QACzB;QACA,MAAMI,cAAc,GAAG,MAAML,eAAe,CAAC1D,SAAS,CAAC+D,cAAc,CACpE,IAAI,CAAClH,iBAAiB,EACtB,IAAI,CAACyD,2BAA2B,CAACC,QAAQ,EAAEC,QAAQ,CAAC,EACpDZ,SAAS,CACT;QACD,IAAI,CAAC+D,gBAAgB,EAAE;UACtB,OAAO,CAAC,CAAC;QACV,CAAC,MAAM;UACN,OAAOI,cAAc;QACtB;MACD,CAAC,CAAC,CACDX,KAAK,CAAC,UAAUjE,MAAe,EAAE;QACjCjC,GAAG,CAACkC,KAAK,CAAC,+BAA+B,EAAED,MAAM,CAAW;QAC5D,MAAMA,MAAM;MACb,CAAC,CAAC,CACD6E,OAAO,CAAC,MAAM;QACdtE,UAAU,CAACuE,MAAM,CAAC,IAAI,CAAC;QACvBvE,UAAU,CAACuE,MAAM,CAAC,IAAI,CAACrH,aAAa,CAACkD,cAAc,EAAE,CAAC;MACvD,CAAC,CAAC;IACJ;;IAEA;AACD;AACA;AACA;AACA,OAJC;IAAA,OAKAoE,yBAAyB,GAAzB,qCAA4B;MAC3B,OAAO,IAAI,CAACjH,cAAc;IAC3B;;IAEA;AACD;AACA,OAFC;IAAA,OAGAkH,uBAAuB,GAAvB,mCAA0B;MACzB,IAAI,IAAI,CAAClH,cAAc,EAAE;QACxB,IAAI,CAACA,cAAc,GAAG,KAAK;MAC5B;IACD,CAAC;IAAA;EAAA,EA5T4BmH,UAAU;EA+TxC;AACA;AACA;EAFA,OAGe1H,eAAe;AAAA"}

package/src/sap/fe/core/AppStateHandler.ts

@@ -5,6 +5,7 @@ import type { NavigationParameter } from "sap/fe/core/controllerextensions/ViewS
 import { defineUI5Class } from "sap/fe/core/helpers/ClassSupport";
 import type { InternalModelContext } from "sap/fe/core/helpers/ModelHelper";
 import toES6Promise from "sap/fe/core/helpers/ToES6Promise";
+import type { InnerAppData } from "sap/fe/navigation/NavigationHandler";
 import type { SelectionVariant } from "sap/fe/navigation/SelectionVariant";
 import library from "sap/fe/navigation/library";
 import BaseObject from "sap/ui/base/Object";
@@ -37,6 +38,14 @@ export type AppDataInfo = {
 	appStateKey: string | null;
 };
 
+export type CreateAppParameters = {
+	replaceHash?: boolean;
+	skipMerge?: boolean;
+	viewId?: string;
+};
+
+const REPLACE_COMPLETE_APPSTATE = "REPLACE_COMPLETE_APPSTATE";
+
 @defineUI5Class("sap.fe.core.AppStateHandler")
 class AppStateHandler extends BaseObject {
 	public sId: string;
@@ -47,13 +56,13 @@ class AppStateHandler extends BaseObject {
 
 	private _mCurrentAppState?: AppState = {};
 
-	nbSimultaneousCreateRequest: number;
+	simultaneousCreateRequest: Record<string, number>;
 
 	constructor(oAppComponent: AppComponent) {
 		super();
 		this.oAppComponent = oAppComponent;
 		this.sId = `${oAppComponent.getId()}/AppStateHandler`;
-		this.nbSimultaneousCreateRequest = 0;
+		this.simultaneousCreateRequest = {};
 		this.bNoRouteChange = false;
 		Log.info("APPSTATE : Appstate handler initialized");
 	}
@@ -63,62 +72,150 @@ class AppStateHandler extends BaseObject {
 	}
 
 	/**
-	 * Creates or updates the appstate.
-	 * Replaces the hash with the new appstate based on replaceHash
+	 * Get the view-specific appstate.
 	 *
-	 * @param createAppParameters Parameters for creating new appstate
-	 * @param createAppParameters.replaceHash Boolean which determines to replace the hash with the new generated key
-	 * @param createAppParameters.skipMerge Boolean which determines to skip the key user shine through
-	 * @returns A promise resolving the stored data or appstate key based on returnKey property
+	 * @param innerAppState Overall appstate
+	 * @param stateIdentifier State identifier, id of the local view
+	 * @returns Inner appstate
 	 */
-	async createAppState(createAppParameters?: { replaceHash?: boolean; skipMerge?: boolean }): Promise<void | AppDataInfo> {
-		if (!this.oAppComponent.getEnvironmentCapabilities().getCapabilities().AppState || BusyLocker.isLocked(this)) {
-			return;
+	_getInnerAppStateForView(innerAppState: InnerAppData | undefined, stateIdentifier: string): InnerAppData | undefined {
+		if (stateIdentifier === REPLACE_COMPLETE_APPSTATE || !innerAppState) {
+			// overall app state needs to be considered.
+			return innerAppState;
 		}
-		const { replaceHash = true, skipMerge = false } = createAppParameters || {};
 
-		const navigationService = this.oAppComponent.getNavigationService(),
-			routerProxy = this.oAppComponent.getRouterProxy(),
+		// we take the subset of the app state wrt to the local view id.
+		return {
+			[stateIdentifier]: innerAppState[stateIdentifier as keyof typeof innerAppState] || {}
+		};
+	}
+
+	/**
+	 * Add appstate in hash.
+	 *
+	 * @param appStateKey Appstate key
+	 * @param stateIdentifier State identifier, Id of the local view
+	 */
+	_addAppStateInHash(appStateKey: string, stateIdentifier: string): void {
+		const appComponent = this.oAppComponent,
+			navigationService = appComponent.getNavigationService(),
+			routerProxy = appComponent.getRouterProxy(),
 			hash = routerProxy.getHash(),
-			controller = this.oAppComponent.getRootControl().getController(),
-			isStickyMode = ModelHelper.isStickySessionSupported(this.oAppComponent.getMetaModel());
+			isStickyMode = ModelHelper.isStickySessionSupported(appComponent.getMetaModel()),
+			newHash = navigationService.replaceInnerAppStateKey(routerProxy.getFullHash(), appStateKey);
 
-		if (!controller.viewState) {
-			throw new Error(`viewState controller extension not available for controller: ${controller.getMetadata().getName()}`);
+		if (this.simultaneousCreateRequest[stateIdentifier] === 0 && newHash !== hash) {
+			routerProxy.navToHash(newHash, undefined, undefined, undefined, !isStickyMode);
+			this.bNoRouteChange = true;
 		}
-		let innerAppState = await controller.viewState.retrieveViewState();
-		if (skipMerge) {
-			innerAppState = { ...innerAppState, ...{ skipMerge } };
+		Log.info("APPSTATE: navToHash");
+	}
+
+	/**
+	 * Create Appstate Key.
+	 *
+	 * @param appStateData Appstate
+	 * @param stateIdentifier State identifier, Id of the local view
+	 * @returns Appstate Key
+	 */
+	async _createAppStateKey(appStateData: InnerAppData, stateIdentifier: string): Promise<string> {
+		const appComponent = this.oAppComponent,
+			navigationService = appComponent.getNavigationService();
+
+		if (this.simultaneousCreateRequest[stateIdentifier]) {
+			// any other value
+			this.simultaneousCreateRequest[stateIdentifier]++;
+		} else {
+			// 0 or undefined
+			this.simultaneousCreateRequest[stateIdentifier] = 1;
 		}
-		const appStateData = { appState: innerAppState };
+
+		const appStateKey = await navigationService.storeInnerAppStateAsync(appStateData, true, true);
+
+		this.simultaneousCreateRequest[stateIdentifier]--;
+
+		Log.info("APPSTATE: Appstate stored");
+		return appStateKey;
+	}
+
+	/**
+	 * Creates appstate info.
+	 *
+	 * @param innerAppState
+	 * @param createAppParameters Parameters for creating a new appstate
+	 * @param createAppParameters.replaceHash A Boolean that determines whether to replace the hash with the newly generated key
+	 * @param createAppParameters.viewId Id of the view for which we need to create the app state. This allows us to create or update view-specific appstate.
+	 * @returns A promise that resolves the stored data or appstate keys
+	 */
+	async _getAppStateInfo(innerAppState: InnerAppData | undefined, createAppParameters?: CreateAppParameters): Promise<AppDataInfo> {
+		const appComponent = this.oAppComponent;
+		const { replaceHash = true, viewId: stateIdentifier = REPLACE_COMPLETE_APPSTATE } = createAppParameters ?? {};
+
 		let appStateKey: string | null = null;
-		if (innerAppState && !deepEqual(this._mCurrentAppState, innerAppState)) {
-			this._mCurrentAppState = innerAppState as Record<string, unknown>;
+		let appStateData = { appState: this._mCurrentAppState };
+
+		const currentStateToUpdate = this._getInnerAppStateForView(this._mCurrentAppState, stateIdentifier);
+		if (innerAppState && !deepEqual(currentStateToUpdate, innerAppState)) {
+			//
+			this._mCurrentAppState = { ...this._mCurrentAppState, ...(innerAppState as Record<string, unknown>) };
+			appStateData = { appState: this._mCurrentAppState };
 			try {
-				this.nbSimultaneousCreateRequest++;
-				appStateKey = await navigationService.storeInnerAppStateAsync(appStateData, true, true);
-				Log.info("APPSTATE: Appstate stored");
+				appStateKey = await this._createAppStateKey(appStateData, stateIdentifier);
 				if (replaceHash === true) {
-					const sNewHash = navigationService.replaceInnerAppStateKey(hash, appStateKey);
-					this.nbSimultaneousCreateRequest--;
-					if (this.nbSimultaneousCreateRequest === 0 && sNewHash !== hash) {
-						routerProxy.navToHash(sNewHash, undefined, undefined, undefined, !isStickyMode);
-						this.bNoRouteChange = true;
-					}
-					Log.info("APPSTATE: navToHash");
+					this._addAppStateInHash(appStateKey, stateIdentifier);
 				}
 			} catch (oError: unknown) {
 				Log.error(oError as string);
 			}
 		} else {
+			const routerProxy = appComponent.getRouterProxy(),
+				hash = routerProxy.getHash();
 			appStateKey = routerProxy.findAppStateInHash(hash) as string;
 		}
 		return {
-			appStateData: appStateData,
-			appStateKey: appStateKey
+			appStateData,
+			appStateKey
 		};
 	}
 
+	/**
+	 * Creates or updates the appstate.
+	 * Replaces the hash with the new appstate based on replaceHash
+	 *
+	 * @param createAppParameters Parameters for creating new appstate
+	 * @param createAppParameters.replaceHash Boolean which determines to replace the hash with the new generated key
+	 * @param createAppParameters.skipMerge Boolean which determines to skip the key user shine through
+	 * @param createAppParameters.viewId Id of the view for which we need to create the app state. This allows us to create or update view-specific appstate.
+	 * @returns A promise resolving the stored data or appstate key
+	 */
+	async createAppState(createAppParameters?: CreateAppParameters): Promise<void | AppDataInfo> {
+		const appComponent = this.oAppComponent;
+		if (!appComponent.getEnvironmentCapabilities().getCapabilities().AppState || BusyLocker.isLocked(this)) {
+			return;
+		}
+		const { skipMerge = false, viewId: stateIdentifier = REPLACE_COMPLETE_APPSTATE } = createAppParameters ?? {},
+			rootController = appComponent.getRootControl().getController();
+
+		if (!rootController.viewState) {
+			throw new Error(`viewState controller extension not available for controller: ${rootController.getMetadata().getName()}`);
+		}
+
+		// In case, on load of FCL app we have multiple views(LR, OP, sub-OP...) and url has iAppState(1).
+		// The LR view loads with applied iAppState(1) and calls createAppState(example: onSearch event in LR) before OP is loaded.
+		// This creates iAppState(2) before iAppState(1) is applied to OP.
+		// So, we try to wait till the routing is complete.
+		await rootController.routingIsComplete();
+
+		// Get appState to update
+		let innerAppState = (await rootController.viewState.retrieveViewState()) as InnerAppData | undefined;
+		innerAppState = this._getInnerAppStateForView(innerAppState, stateIdentifier);
+		if (skipMerge) {
+			innerAppState = { ...innerAppState, ...{ skipMerge } };
+		}
+
+		return this._getAppStateInfo(innerAppState, createAppParameters);
+	}
+
 	_createNavigationParameters(oAppData: AppData, sNavType: string): NavigationParameter {
 		return Object.assign({}, oAppData, {
 			selectionVariantDefaults: oAppData.oDefaultedSelectionVariant,
@@ -217,9 +314,9 @@ class AppStateHandler extends BaseObject {
 				const appStateData = this._getAppStateData(oAppData, viewId, sNavType);
 				// fetch the skipMerge flag from appState for save as tile
 				const skipMerge: boolean | undefined = oAppData?.appState?.[SKIP_MERGE_KEY];
-				this._mCurrentAppState = sNavType === NavType.iAppState || sNavType === NavType.hybrid ? appStateData : undefined;
+				this._mCurrentAppState =
+					sNavType === NavType.iAppState || sNavType === NavType.hybrid ? { ...this._mCurrentAppState, ...appStateData } : {};
 				let shouldApplyState = true;
-
 				if (!oRootController.viewState) {
 					throw new Error(`viewState extension required for controller ${oRootController.getMetadata().getName()}`);
 				}