@sapui5/sap.fe.core 1.141.2 → 1.142.1

package/src/sap/fe/core/controllerextensions/messageHandler/messageHandling.ts

@@ -1025,21 +1025,22 @@ function closeMessageBox(messageShown: MessageWithHeader, callBack: (value: void
 }
 
 function showMessageBoxPerType(formattedText: string, close: { onClose: Function }, message: Message): void {
+	const parameters = { ...close, closeOnNavigation: false };
 	switch (message.getType()) {
 		case MessageType.Error:
-			MessageBox.error(formattedText, close);
+			MessageBox.error(formattedText, parameters);
 			break;
 		case MessageType.Warning:
-			MessageBox.warning(formattedText, close);
+			MessageBox.warning(formattedText, parameters);
 			break;
 		case MessageType.Success:
-			MessageBox.success(formattedText, close);
+			MessageBox.success(formattedText, parameters);
 			break;
 		case MessageType.Information:
-			MessageBox.information(formattedText, close);
+			MessageBox.information(formattedText, parameters);
 			break;
 		default:
-			MessageBox.show(formattedText, close);
+			MessageBox.show(formattedText, parameters);
 	}
 }
 

package/src/sap/fe/core/controllerextensions/routing/RouterProxy.js

@@ -198,33 +198,34 @@ sap.ui.define(["sap/base/Log", "sap/fe/base/ClassSupport", "sap/fe/core/helpers/
      * @param bPreserveHistory If set to true, non-ancestor entries in history will be retained
      * @param bDisablePreservationCache If set to true, cache preservation mechanism is disabled for the current navigation
      * @param bForceFocus If set to true, the logic to set the focus once the navigation is finalized will be triggered (onPageReady)
-     * @param bPreserveShellBackNavigationHandler If not set to false, the back navigation is set to undefined
+     * @param preserveShellBackNavigationHandler If set to true, the back navigation callback is preserved. If undefined or false, the back navigation callback is reset.
+     * @param skipHashGuardCheck
      * @returns Promise (resolved when the navigation is finalized) that returns 'true' if a navigation took place, 'false' if the navigation didn't happen
      */;
-    _proto.navToHash = async function navToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus, bPreserveShellBackNavigationHandler) {
+    _proto.navToHash = async function navToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus, preserveShellBackNavigationHandler, skipHashGuardCheck) {
       sHash = sHash.startsWith("/") ? sHash.substring(1) : sHash;
-      if (bPreserveShellBackNavigationHandler !== false) {
+      if (!preserveShellBackNavigationHandler) {
         await this._oShellServices.setBackNavigation();
       }
       sHash = this.removeRestoreHistoryFlagFromHash(sHash);
       if (this._oRouteMatchSynchronization) {
         return this._oRouteMatchSynchronization.waitFor().then(async () => {
           this._oRouteMatchSynchronization = undefined;
-          return this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus);
+          return this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus, skipHashGuardCheck);
         });
       } else {
         if (this._bActivateRouteMatchSynchro) {
           this.waitForRouteMatchBeforeNavigation();
         }
-        return this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus);
+        return this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus, skipHashGuardCheck);
       }
     };
-    _proto._internalNavToHash = async function _internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus) {
+    _proto._internalNavToHash = async function _internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus, skipHashGuardCheck) {
       // Add the app state in the hash if needed
       if (this.fclEnabled && this.sIAppStateKey && !this.findAppStateInHash(sHash)) {
         sHash = this.setAppStateInHash(sHash, this.sIAppStateKey);
       }
-      if (!this.checkHashWithGuard(sHash)) {
+      if (!this.checkHashWithGuard(sHash) && !(skipHashGuardCheck ?? false)) {
         if (!this.oResourceBundle) {
           this.oResourceBundle = Library.getResourceBundleFor("sap.fe.core");
         }
@@ -320,11 +321,12 @@ sap.ui.define(["sap/base/Log", "sap/fe/base/ClassSupport", "sap/fe/core/helpers/
      * @param oParameters Parameters for the navigation
      * @param oParameters.noPreservationCache
      * @param oParameters.bIsStickyMode
+     * @param oParameters.isHiddenDraftEnabled
      * @returns Promise that is resolved when the navigation is finalized
      */;
     _proto.navTo = async function navTo(sRouteName, oParameters) {
       const sHash = this._oRouter.getURL(sRouteName, oParameters);
-      return this.navToHash(sHash, false, oParameters?.noPreservationCache, false, !oParameters?.bIsStickyMode);
+      return this.navToHash(sHash, false, oParameters?.noPreservationCache, false, (oParameters?.bIsStickyMode ?? false) || (oParameters?.isHiddenDraftEnabled ?? false));
     }
 
     /**
@@ -934,4 +936,4 @@ sap.ui.define(["sap/base/Log", "sap/fe/base/ClassSupport", "sap/fe/core/helpers/
   }(BaseObject)) || _class);
   return RouterProxy;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["enumState","EQUAL","COMPATIBLE","ANCESTOR","DIFFERENT","enumURLParams","LAYOUTPARAM","IAPPSTATEPARAM","createGuardFromHash","sGuardHash","hashTraker","_guardHash","replace","hashTracker","undefined","check","sHash","indexOf","removeAppStateInHash","RegExp","RouterProxy","_dec","defineUI5Class","_class","_BaseObject","_this","_len","arguments","length","args","Array","_key","call","bIsRebuildHistoryRunning","bIsComputingTitleHierachy","bIsGuardCrossAllowed","sIAppStateKey","_bActivateRouteMatchSynchro","_bApplyRestore","_pathMappings","restoreHistoryTriggered","appStateUpdating","_inheritsLoose","_proto","prototype","init","oAppComponent","isfclEnabled","getService","then","asyncInit","catch","oError","Log","error","_fnHashGuard","hashGuard","bind","window","addEventListener","_bDisableOnHashChange","_bIgnoreRestore","_bForceFocus","_oShellServices","getShellServices","initRaw","getRouter","routingHints","getRoutingService","getRoutingHints","waitForRouteMatchBeforeNavigation","history","replaceState","Object","assign","feLevel","state","location","fclEnabled","_fnBlockingNavFilter","_blockingNavigationFilter","registerNavigationFilter","destroy","unregisterNavigationFilter","removeEventListener","setAppStateInHash","sAppStateKey","sNewHash","includes","findAppStateInHash","aAppState","match","getDecodedWindowHash","decodeURI","hash","oRouter","_oRouter","_oManagedHistory","_oNavigationGuard","sCurrentAppHash","getHash","push","_extractStateFromHash","appName","getAppNameFromHash","getFullHash","splitHash","appSpecificRoute","getHashChanger","shellPart","isFocusForced","setFocusForced","bForced","removeIAppStateKey","setAppStateUpdating","updatingAppState","isAppStateUpdating","removeRestoreHistoryFlagFromHash","navToHash","bPreserveHistory","bDisablePreservationCache","bForceFocus","bPreserveShellBackNavigationHandler","startsWith","substring","setBackNavigation","_oRouteMatchSynchronization","waitFor","_internalNavToHash","checkHashWithGuard","oResourceBundle","Library","getResourceBundleFor","confirm","getText","Promise","resolve","oNewState","aCurrentHashKeys","extractEntitySetsFromHash","keys","every","key","index","oHistoryAction","_pushNewState","storeFocusInfoForCurrentHash","_rebuildBrowserHistory","restoreHistory","sTargetHash","checkRestoreHistoryWasTriggered","resetRestoreHistoryFlag","navBack","sCurrentHash","sPreviousHash","i","back","navTo","sRouteName","oParameters","getURL","noPreservationCache","bIsStickyMode","exitFromApp","backToPreviousApp","isCurrentStateImpactedBy","oLocalGuard","isNavigationFinalized","setNavigationGuard","discardNavigationGuard","hasNavigationGuard","isGuardCrossAllowedByUser","activateRouteMatchSynchronization","resolveRouteMatch","Synchronization","sHashNoParams","split","aTokens","names","forEach","sToken","oState","screenMode","aLayout","sLayout","bRebuildOnly","bDisableHistoryPreservation","lastIndex","iPopCount","pop","preserved","oLastRemovedItem","oTopState","_compareCacheStates","sPreviousIAppStateKey","oComparisonStateResult","bHasSameHash","focusControlId","secondaryFocusControlId","focusInfo","secondaryFocusInfo","type","steps","_disableEventOnHashChange","stop","_enableEventOnHashChange","bIgnoreCurrentHash","initialize","that","oTargetState","newLevel","replaceAsync","replaceHash","setTimeout","backReplaceAsync","backAsync","setHash","go","getLastHistoryEntry","setPathMapping","mappings","filter","mapping","oldPath","newPath","currentAppName","isInitialized","find","m","encodeURI","aHashSplit","sAppHash","oState1","oState2","equal","parentOf","splitAppSpecificRoute","routeSplit","shift","checkIfBackIsOutOfGuard","segments","previousHash","checkIfBackExitsApp","checkIfBackHasSameContext","oCurrentState","oPreviousState","restoreFocusForCurrentHash","currentHash","stateForHash","focusApplied","focusControl","Element","getElementById","useSecondary","getFocusDomRef","getParent","isA","getBusy","focus","getActiveElement","getId","parentTable","preventScroll","getFocusInfo","findLayoutForHash","hashNoParam","targetState","BaseObject"],"sourceRoot":".","sources":["RouterProxy.ts"],"sourcesContent":["import Log from \"sap/base/Log\";\nimport type ResourceBundle from \"sap/base/i18n/ResourceBundle\";\nimport { defineUI5Class } from \"sap/fe/base/ClassSupport\";\nimport type AppComponent from \"sap/fe/core/AppComponent\";\nimport Synchronization from \"sap/fe/core/helpers/Synchronization\";\nimport type { IShellServices } from \"sap/fe/core/services/ShellServicesFactory\";\nimport type MTable from \"sap/m/Table\";\nimport BaseObject from \"sap/ui/base/Object\";\nimport Element from \"sap/ui/core/Element\";\nimport Library from \"sap/ui/core/Lib\";\nimport type Router from \"sap/ui/core/routing/Router\";\nimport type Table from \"sap/ui/mdc/Table\";\nimport type UITable from \"sap/ui/table/Table\";\n\nconst enumState = {\n\tEQUAL: 0,\n\tCOMPATIBLE: 1,\n\tANCESTOR: 2,\n\tDIFFERENT: 3\n};\nconst enumURLParams = {\n\tLAYOUTPARAM: \"layout\",\n\tIAPPSTATEPARAM: \"sap-iapp-state\"\n};\n\ntype RouterState = {\n\tkeys: string[];\n\thash: string;\n\tpreserved?: boolean;\n\tsLayout?: string;\n\tscreenMode: number;\n\tfocusControlId?: string;\n\tsecondaryFocusControlId?: string;\n\tfocusInfo?: {\n\t\tpreventScroll?: boolean;\n\t\ttargetInfo?: unknown;\n\t};\n\tsecondaryFocusInfo?: {\n\t\tpreventScroll?: boolean;\n\t};\n};\n\ntype OtherHistoryAction = { type: \"append\" | \"none\" | \"replace\" };\nexport type BackHistoryAction = { type: \"back\" | \"back-replace\"; steps: number };\ntype HystoryAction = BackHistoryAction | OtherHistoryAction;\n\ntype NavigationGuard = { _guardHash: string; hashTracker: string | undefined; check: (hash: string) => boolean };\n/**\n * Creates a HashGuard object.\n * @param sGuardHash The hash used for the guard.\n * @param [hashTraker] Optional hash tracker used for additional guard checks.\n * @returns The created hash guard.\n */\nfunction createGuardFromHash(sGuardHash: string, hashTraker?: string): NavigationGuard {\n\treturn {\n\t\t_guardHash: sGuardHash.replace(/\\?[^?]*$/, \"\"), // Remove query part\n\t\thashTracker: hashTraker ? hashTraker.replace(/\\?[^?]*$/, \"\") : undefined,\n\t\tcheck: function (sHash: string): boolean {\n\t\t\treturn sHash.indexOf(this._guardHash) === 0 || (this.hashTracker ? sHash.indexOf(this.hashTracker) === 0 : false);\n\t\t}\n\t};\n}\n/**\n * Returns a hash without its iAppState part.\n * @param sHash The hash\n * @returns The hash without the iAppState\n */\nfunction removeAppStateInHash(sHash: string): string {\n\treturn sHash.replace(new RegExp(`[&?]*${enumURLParams.IAPPSTATEPARAM}=[^&]*`), \"\");\n}\n\n@defineUI5Class(\"sap.fe.core.RouterProxy\")\nclass RouterProxy extends BaseObject {\n\tbIsRebuildHistoryRunning = false;\n\n\tbIsComputingTitleHierachy = false;\n\n\tbIsGuardCrossAllowed = false;\n\n\tsIAppStateKey: string | null = null;\n\n\t_oShellServices!: IShellServices;\n\n\tfclEnabled!: boolean;\n\n\t_fnBlockingNavFilter!: Function;\n\n\t_fnHashGuard!: (this: Window, popStateEvent: PopStateEvent) => unknown;\n\n\t_bDisableOnHashChange!: boolean;\n\n\t_bIgnoreRestore!: boolean;\n\n\t_bForceFocus!: boolean;\n\n\t_oRouter!: Router;\n\n\t_oManagedHistory!: RouterState[];\n\n\t_oNavigationGuard!: NavigationGuard | null;\n\n\toResourceBundle?: ResourceBundle;\n\n\t_oRouteMatchSynchronization?: Synchronization;\n\n\t_bActivateRouteMatchSynchro = false;\n\n\t_bApplyRestore = false;\n\n\t_pathMappings: { oldPath: string; newPath: string }[] = [];\n\n\trestoreHistoryTriggered = false;\n\n\troutingHints?: Record<string, { parentOf: string[] }>;\n\n\tappName!: string;\n\n\tappStateUpdating = false;\n\n\tinit(oAppComponent: AppComponent, isfclEnabled: boolean): void {\n\t\t// Save the name of the app (including startup parameters) for rebuilding full hashes later\n\t\toAppComponent\n\t\t\t.getService(\"shellServices\")\n\t\t\t.then(() => this.asyncInit(oAppComponent, isfclEnabled))\n\t\t\t.catch(function (oError: unknown) {\n\t\t\t\tLog.error(\"Cannot retrieve the shell services\", oError as string);\n\t\t\t});\n\t\tthis._fnHashGuard = this.hashGuard.bind(this);\n\t\twindow.addEventListener(\"popstate\", this._fnHashGuard);\n\t\tthis._bDisableOnHashChange = false;\n\t\tthis._bIgnoreRestore = false;\n\t\tthis._bForceFocus = true; // Trigger the focus mechanism for the first view displayed by the app\n\t}\n\n\tasyncInit(oAppComponent: AppComponent, isfclEnabled: boolean): void {\n\t\tthis._oShellServices = oAppComponent.getShellServices();\n\t\tthis.initRaw(oAppComponent.getRouter());\n\t\tthis.routingHints = oAppComponent.getRoutingService().getRoutingHints();\n\t\t// We want to wait until the initial routeMatched is done before doing any navigation\n\t\tthis.waitForRouteMatchBeforeNavigation();\n\n\t\t// Set feLevel=0 for the first Application page in the history\n\t\thistory.replaceState(\n\t\t\tObject.assign(\n\t\t\t\t{\n\t\t\t\t\tfeLevel: 0\n\t\t\t\t},\n\t\t\t\thistory.state\n\t\t\t),\n\t\t\t\"\",\n\t\t\twindow.location as unknown as string\n\t\t);\n\t\tthis.fclEnabled = isfclEnabled;\n\n\t\tthis._fnBlockingNavFilter = this._blockingNavigationFilter.bind(this);\n\t\tthis._oShellServices.registerNavigationFilter(this._fnBlockingNavFilter);\n\t}\n\n\tdestroy(): void {\n\t\tif (this._oShellServices) {\n\t\t\tthis._oShellServices.unregisterNavigationFilter(this._fnBlockingNavFilter);\n\t\t}\n\t\twindow.removeEventListener(\"popstate\", this._fnHashGuard);\n\t}\n\n\t/**\n\t * Adds an iAppState inside a hash (or replaces an existing one).\n\t * @param sHash The hash\n\t * @param sAppStateKey The iAppState to add\n\t * @returns The hash with the app state\n\t */\n\tsetAppStateInHash(sHash: string, sAppStateKey: string): string {\n\t\tlet sNewHash: string;\n\n\t\tif (sHash.includes(enumURLParams.IAPPSTATEPARAM)) {\n\t\t\t// If there's already an iAppState parameter in the hash, replace it\n\t\t\tsNewHash = sHash.replace(\n\t\t\t\tnew RegExp(`${enumURLParams.IAPPSTATEPARAM}=[^&]*`),\n\t\t\t\t`${enumURLParams.IAPPSTATEPARAM}=${sAppStateKey}`\n\t\t\t);\n\t\t} else {\n\t\t\t// Add the iAppState parameter in the hash\n\t\t\tif (!sHash.includes(\"?\")) {\n\t\t\t\tsNewHash = `${sHash}?`;\n\t\t\t} else {\n\t\t\t\tsNewHash = `${sHash}&`;\n\t\t\t}\n\t\t\tsNewHash += `${enumURLParams.IAPPSTATEPARAM}=${sAppStateKey}`;\n\t\t}\n\n\t\treturn sNewHash;\n\t}\n\n\t/**\n\t * Returns the iAppState part from a hash (or null if not found).\n\t * @param sHash The hash\n\t * @returns The iAppState part of the hash\n\t */\n\tfindAppStateInHash(sHash: string): string | null {\n\t\tconst aAppState = sHash.match(new RegExp(`\\\\?.*${enumURLParams.IAPPSTATEPARAM}=([^&]*)`));\n\t\treturn aAppState && aAppState.length > 1 ? aAppState[1] : null;\n\t}\n\n\tprivate getDecodedWindowHash(): string {\n\t\treturn decodeURI(window.location.hash);\n\t}\n\n\t/**\n\t * Raw initialization (for unit tests).\n\t * @param oRouter The router used by this proxy\n\t */\n\tinitRaw(oRouter: Router): void {\n\t\tthis._oRouter = oRouter;\n\t\tthis._oManagedHistory = [];\n\t\tthis._oNavigationGuard = null;\n\n\t\tconst sCurrentAppHash = this.getHash();\n\t\tthis._oManagedHistory.push(this._extractStateFromHash(sCurrentAppHash));\n\n\t\tthis.appName = this.getAppNameFromHash(this.getDecodedWindowHash());\n\n\t\t// Set the iAppState if the initial hash contains one\n\t\tthis.sIAppStateKey = this.findAppStateInHash(sCurrentAppHash);\n\t}\n\n\t/**\n\t * Return the full app-specific hash part from window.location.hash.\n\t *\n\t * Compared to {@link getHash} this function includes sub-routes of nested components.\n\t * @returns The app-specific hash part (i.e., without the shell part), or an empty string if there is none.\n\t */\n\tgetFullHash(): string {\n\t\tconst splitHash = this._oShellServices.splitHash(this.getDecodedWindowHash());\n\n\t\tif (\"appSpecificRoute\" in splitHash) {\n\t\t\treturn splitHash.appSpecificRoute?.replace(/^&\\//, \"\") ?? \"\"; // remove the leading \"&/\"\n\t\t}\n\t\treturn \"\";\n\t}\n\n\tgetHash(): string {\n\t\treturn this._oRouter.getHashChanger().getHash() ?? \"\";\n\t}\n\n\tprotected getAppNameFromHash(hash: string): string {\n\t\tconst splitHash = this._oShellServices?.splitHash(hash) as { shellPart: string; appSpecificRoute: string } | undefined;\n\t\treturn splitHash?.shellPart ?? \"\";\n\t}\n\n\tisFocusForced(): boolean {\n\t\treturn this._bForceFocus;\n\t}\n\n\tsetFocusForced(bForced: boolean): void {\n\t\tthis._bForceFocus = bForced;\n\t}\n\n\t/**\n\t * Resets the internal variable sIAppStateKey.\n\t *\n\t */\n\tremoveIAppStateKey(): void {\n\t\tthis.sIAppStateKey = null;\n\t}\n\n\tsetAppStateUpdating(updatingAppState: boolean): void {\n\t\tthis.appStateUpdating = updatingAppState;\n\t}\n\n\tisAppStateUpdating(): boolean {\n\t\treturn this.appStateUpdating;\n\t}\n\n\tprivate removeRestoreHistoryFlagFromHash(hash: string): string {\n\t\treturn hash.replace(\"restoreHistory=true&\", \"\").replace(/[?&]restoreHistory=true/, \"\");\n\t}\n\n\t/**\n\t * Navigates to a specific hash.\n\t * @param sHash Hash to be navigated to\n\t * @param bPreserveHistory If set to true, non-ancestor entries in history will be retained\n\t * @param bDisablePreservationCache If set to true, cache preservation mechanism is disabled for the current navigation\n\t * @param bForceFocus If set to true, the logic to set the focus once the navigation is finalized will be triggered (onPageReady)\n\t * @param bPreserveShellBackNavigationHandler If not set to false, the back navigation is set to undefined\n\t * @returns Promise (resolved when the navigation is finalized) that returns 'true' if a navigation took place, 'false' if the navigation didn't happen\n\t */\n\tasync navToHash(\n\t\tsHash: string,\n\t\tbPreserveHistory?: boolean,\n\t\tbDisablePreservationCache?: boolean,\n\t\tbForceFocus?: boolean,\n\t\tbPreserveShellBackNavigationHandler?: boolean\n\t): Promise<boolean> {\n\t\tsHash = sHash.startsWith(\"/\") ? sHash.substring(1) : sHash;\n\t\tif (bPreserveShellBackNavigationHandler !== false) {\n\t\t\tawait this._oShellServices.setBackNavigation();\n\t\t}\n\t\tsHash = this.removeRestoreHistoryFlagFromHash(sHash);\n\t\tif (this._oRouteMatchSynchronization) {\n\t\t\treturn this._oRouteMatchSynchronization.waitFor().then(async () => {\n\t\t\t\tthis._oRouteMatchSynchronization = undefined;\n\t\t\t\treturn this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus);\n\t\t\t});\n\t\t} else {\n\t\t\tif (this._bActivateRouteMatchSynchro) {\n\t\t\t\tthis.waitForRouteMatchBeforeNavigation();\n\t\t\t}\n\t\t\treturn this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus);\n\t\t}\n\t}\n\n\tasync _internalNavToHash(\n\t\tsHash: string,\n\t\tbPreserveHistory?: boolean,\n\t\tbDisablePreservationCache?: boolean,\n\t\tbForceFocus?: boolean\n\t): Promise<boolean> {\n\t\t// Add the app state in the hash if needed\n\t\tif (this.fclEnabled && this.sIAppStateKey && !this.findAppStateInHash(sHash)) {\n\t\t\tsHash = this.setAppStateInHash(sHash, this.sIAppStateKey);\n\t\t}\n\n\t\tif (!this.checkHashWithGuard(sHash)) {\n\t\t\tif (!this.oResourceBundle) {\n\t\t\t\tthis.oResourceBundle = Library.getResourceBundleFor(\"sap.fe.core\")!;\n\t\t\t}\n\n\t\t\t// We have to use a confirm here for UI consistency reasons, as with some scenarios\n\t\t\t// in the EditFlow we rely on a UI5 mechanism that displays a confirm dialog.\n\t\t\t// eslint-disable-next-line no-alert\n\t\t\tif (!confirm(this.oResourceBundle.getText(\"C_ROUTER_PROXY_SAPFE_EXIT_NOTSAVED_MESSAGE\"))) {\n\t\t\t\t// The user clicked on Cancel --> cancel navigation\n\t\t\t\treturn Promise.resolve(false);\n\t\t\t}\n\t\t\tthis.bIsGuardCrossAllowed = true;\n\t\t}\n\n\t\t// In case the navigation will cause a new view to be displayed, we force the focus\n\t\t// I.e. if the keys for the hash we're navigating to is a superset of the current hash keys.\n\t\tconst oNewState = this._extractStateFromHash(sHash);\n\t\tif (!this._bForceFocus) {\n\t\t\t// If the focus was already forced, keep it\n\t\t\tconst aCurrentHashKeys = RouterProxy.extractEntitySetsFromHash(this.getHash());\n\t\t\tthis._bForceFocus =\n\t\t\t\tbForceFocus ||\n\t\t\t\t(aCurrentHashKeys.length < oNewState.keys.length &&\n\t\t\t\t\taCurrentHashKeys.every(function (key: string, index: number) {\n\t\t\t\t\t\treturn key === oNewState.keys[index];\n\t\t\t\t\t}));\n\t\t}\n\n\t\tconst oHistoryAction = this._pushNewState(oNewState, false, bPreserveHistory, bDisablePreservationCache);\n\t\tthis.storeFocusInfoForCurrentHash();\n\n\t\treturn this._rebuildBrowserHistory(oHistoryAction, false);\n\t}\n\n\t/**\n\t * Clears browser history if entries have been added without using the RouterProxy.\n\t * Updates the internal history accordingly.\n\t * @returns Promise that is resolved once the history is rebuilt\n\t */\n\tasync restoreHistory(): Promise<void | boolean> {\n\t\tif (this._bApplyRestore) {\n\t\t\tthis._bApplyRestore = false;\n\t\t\tlet sTargetHash = this.getHash();\n\t\t\tsTargetHash = this.removeRestoreHistoryFlagFromHash(sTargetHash);\n\t\t\tconst oNewState = this._extractStateFromHash(sTargetHash);\n\n\t\t\tconst oHistoryAction = this._pushNewState(oNewState, true, false, true);\n\n\t\t\tthis.restoreHistoryTriggered = true;\n\t\t\treturn this._rebuildBrowserHistory(oHistoryAction, true);\n\t\t} else {\n\t\t\treturn Promise.resolve();\n\t\t}\n\t}\n\n\t/**\n\t * Checks if RestoreHistory has been triggered on the RouterProxy.\n\t * @returns True if it has been triggered\n\t */\n\tcheckRestoreHistoryWasTriggered(): boolean {\n\t\treturn this.restoreHistoryTriggered;\n\t}\n\n\t/**\n\t * Resets the flag that says if RestoreHistory has been triggered on the RouterProxy.\n\t */\n\tresetRestoreHistoryFlag(): void {\n\t\tthis.restoreHistoryTriggered = false;\n\t}\n\n\t/**\n\t * Navigates back in the history.\n\t * @returns Promise that is resolved when the navigation is finalized\n\t */\n\tasync navBack(): Promise<void | boolean> {\n\t\tconst sCurrentHash = this.getHash();\n\t\tlet sPreviousHash;\n\n\t\t// Look for the current hash in the managed history\n\t\tfor (let i = this._oManagedHistory.length - 1; i > 0; i--) {\n\t\t\tif (this._oManagedHistory[i].hash === sCurrentHash) {\n\t\t\t\tsPreviousHash = this._oManagedHistory[i - 1].hash;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif (sPreviousHash) {\n\t\t\treturn this.navToHash(sPreviousHash);\n\t\t} else {\n\t\t\t// We couldn't find a previous hash in history\n\t\t\t// This can happen when navigating from a transient hash in a create app, and\n\t\t\t// in that case history.back would go back to the FLP\n\t\t\twindow.history.back();\n\t\t\treturn Promise.resolve();\n\t\t}\n\t}\n\n\t/**\n\t * Navigates to a route with parameters.\n\t * @param sRouteName The route name to be navigated to\n\t * @param oParameters Parameters for the navigation\n\t * @param oParameters.noPreservationCache\n\t * @param oParameters.bIsStickyMode\n\t * @returns Promise that is resolved when the navigation is finalized\n\t */\n\tasync navTo(sRouteName: string, oParameters?: { noPreservationCache?: boolean; bIsStickyMode?: boolean }): Promise<boolean> {\n\t\tconst sHash = this._oRouter.getURL(sRouteName, oParameters);\n\t\treturn this.navToHash(sHash!, false, oParameters?.noPreservationCache, false, !oParameters?.bIsStickyMode);\n\t}\n\n\t/**\n\t * Exits the current app by navigating back\n\t * to the previous app (if any) or the FLP.\n\t * @returns Promise that is resolved when we exit the app\n\t */\n\texitFromApp(): void {\n\t\treturn this._oShellServices.backToPreviousApp();\n\t}\n\n\t/**\n\t * Checks whether a given hash can have an impact on the current state\n\t * i.e. if the hash is equal, compatible or an ancestor of the current state.\n\t * @param sHash `true` if there is an impact\n\t * @returns If there is an impact\n\t */\n\tisCurrentStateImpactedBy(sHash: string): boolean {\n\t\tif (sHash[0] === \"/\") {\n\t\t\tsHash = sHash.substring(1);\n\t\t}\n\t\tconst oLocalGuard = createGuardFromHash(sHash);\n\t\treturn oLocalGuard.check(this.getHash());\n\t}\n\n\t/**\n\t * Checks if a navigation is currently being processed.\n\t * @returns `false` if a navigation has been triggered in the RouterProxy and is not yet finalized\n\t */\n\tisNavigationFinalized(): boolean {\n\t\treturn !this.bIsRebuildHistoryRunning;\n\t}\n\n\t/**\n\t * Sets the last state as a guard.\n\t * Each future navigation will be checked against this guard, and a confirmation dialog will\n\t * be displayed before the navigation goes to an ancestor of the guard.\n\t * @param sHash The hash for the guard.\n\t * @param [hashTraker] Optional hash tracker used for additional guard checks.\n\t */\n\tsetNavigationGuard(sHash: string, hashTraker?: string): void {\n\t\tthis._oNavigationGuard = createGuardFromHash(sHash, hashTraker);\n\t\tthis.bIsGuardCrossAllowed = false;\n\t}\n\n\t/**\n\t * Disables the navigation guard.\n\t */\n\tdiscardNavigationGuard(): void {\n\t\tthis._oNavigationGuard = null;\n\t}\n\n\t/**\n\t * Checks for the availability of the navigation guard.\n\t * @returns `true` if navigating guard is available\n\t */\n\thasNavigationGuard(): boolean {\n\t\treturn this._oNavigationGuard !== null;\n\t}\n\n\t/**\n\t * Tests a hash against the navigation guard.\n\t * @param sHash The hash to be tested\n\t * @returns `true` if navigating to the hash doesn't cross the guard\n\t */\n\tcheckHashWithGuard(sHash: string): boolean {\n\t\treturn this._oNavigationGuard === null || this._oNavigationGuard.check(sHash);\n\t}\n\n\t/**\n\t * Checks if the user allowed the navigation guard to be crossed.\n\t * @returns `true` if crossing the guard has been allowed by the user\n\t */\n\tisGuardCrossAllowedByUser(): boolean {\n\t\treturn this.bIsGuardCrossAllowed;\n\t}\n\n\t/**\n\t * Activates the synchronization for routeMatchedEvent.\n\t * The next NavToHash call will create a Synchronization object that will be resolved\n\t * by the corresponding onRouteMatched event, preventing another NavToHash to happen in parallel.\n\t */\n\tactivateRouteMatchSynchronization(): void {\n\t\tthis._bActivateRouteMatchSynchro = true;\n\t}\n\n\t/**\n\t * Resolve the routeMatch synchronization object, unlocking potential pending NavToHash calls.\n\t */\n\tresolveRouteMatch(): void {\n\t\tif (this._oRouteMatchSynchronization) {\n\t\t\tthis._oRouteMatchSynchronization.resolve();\n\t\t}\n\t}\n\n\t/**\n\t * Makes sure no navigation can happen before a routeMatch happened.\n\t */\n\twaitForRouteMatchBeforeNavigation(): void {\n\t\tthis._oRouteMatchSynchronization = new Synchronization();\n\t\tthis._bActivateRouteMatchSynchro = false;\n\t}\n\n\tstatic extractEntitySetsFromHash(sHash: string | undefined): string[] {\n\t\tif (sHash === undefined) {\n\t\t\tsHash = \"\";\n\t\t}\n\t\tconst sHashNoParams = sHash.split(\"?\")[0]; // remove params\n\t\tconst aTokens = sHashNoParams.split(\"/\");\n\t\tconst names: string[] = [];\n\n\t\taTokens.forEach((sToken) => {\n\t\t\tif (sToken.length) {\n\t\t\t\tnames.push(sToken.split(\"(\")[0]);\n\t\t\t}\n\t\t});\n\n\t\treturn names;\n\t}\n\n\t/**\n\t * Builds a state from a hash.\n\t * @param sHash The hash to be used as entry\n\t * @returns The state\n\t */\n\t_extractStateFromHash(sHash: string): RouterState {\n\t\tif (sHash === undefined) {\n\t\t\tsHash = \"\";\n\t\t}\n\n\t\tconst oState: RouterState = {\n\t\t\tkeys: RouterProxy.extractEntitySetsFromHash(sHash),\n\t\t\thash: sHash,\n\t\t\tscreenMode: 0 // will be updated in a sec\n\t\t};\n\n\t\t// Retrieve layout (if any)\n\t\tconst aLayout = sHash.match(new RegExp(`\\\\?.*${enumURLParams.LAYOUTPARAM}=([^&]*)`));\n\t\toState.sLayout = aLayout && aLayout.length > 1 ? aLayout[1] : undefined;\n\t\tif (oState.sLayout === \"MidColumnFullScreen\") {\n\t\t\toState.screenMode = 1;\n\t\t} else if (oState.sLayout === \"EndColumnFullScreen\") {\n\t\t\toState.screenMode = 2;\n\t\t} else {\n\t\t\toState.screenMode = 0;\n\t\t}\n\t\treturn oState;\n\t}\n\n\t/**\n\t * Adds a new state into the internal history structure.\n\t * Makes sure this new state is added after an ancestor.\n\t * Also sets the iAppState key in the whole history.\n\t * @param oNewState The new state to be added\n\t * @param bRebuildOnly `true` if we're rebuilding the history after a shell menu navigation\n\t * @param bPreserveHistory If set to true, non-ancestor entries in history will be retained\n\t * @param bDisableHistoryPreservation Disable the mechanism to retained marked entries in cache\n\t * @returns The new state\n\t * @final\n\t */\n\t_pushNewState(\n\t\toNewState: RouterState,\n\t\tbRebuildOnly: boolean,\n\t\tbPreserveHistory?: boolean,\n\t\tbDisableHistoryPreservation?: boolean\n\t): HystoryAction {\n\t\tconst sCurrentHash = this.removeRestoreHistoryFlagFromHash(this.getHash());\n\t\tlet lastIndex = this._oManagedHistory.length - 1;\n\t\tlet iPopCount = bRebuildOnly ? 1 : 0;\n\n\t\t// 1. Do some cleanup in the managed history : in case the user has navigated back in the browser history, we need to remove\n\t\t// the states ahead in history and make sure the top state corresponds to the current page\n\t\t// We don't do that when restoring the history, as the current state has been added on top of the browser history\n\t\t// and is not reflected in the managed history\n\t\tif (!bRebuildOnly) {\n\t\t\twhile (lastIndex >= 0 && this._oManagedHistory[lastIndex].hash !== sCurrentHash) {\n\t\t\t\tthis._oManagedHistory.pop();\n\t\t\t\tlastIndex--;\n\t\t\t}\n\n\t\t\tif (this._oManagedHistory.length === 0) {\n\t\t\t\t// We couldn't find the current location in the history. This can happen if a browser reload\n\t\t\t\t// happened, causing a reinitialization of the managed history.\n\t\t\t\t// In that case, we use the current location as the new starting point in the managed history\n\t\t\t\tthis._oManagedHistory.push(this._extractStateFromHash(sCurrentHash));\n\t\t\t\thistory.replaceState(Object.assign({ feLevel: 0 }, history.state), \"\");\n\t\t\t}\n\t\t}\n\n\t\t// 2. Mark the top state as preserved if required\n\t\tif (bPreserveHistory && !bDisableHistoryPreservation) {\n\t\t\tthis._oManagedHistory[this._oManagedHistory.length - 1].preserved = true;\n\t\t}\n\n\t\t// 3. Then pop all states until we find an ancestor of the new state, or we find a state that need to be preserved\n\t\tlet oLastRemovedItem;\n\t\twhile (this._oManagedHistory.length > 0) {\n\t\t\tconst oTopState = this._oManagedHistory[this._oManagedHistory.length - 1];\n\t\t\tif (\n\t\t\t\t(bDisableHistoryPreservation || !oTopState.preserved) &&\n\t\t\t\tthis._compareCacheStates(oTopState, oNewState) !== enumState.ANCESTOR\n\t\t\t) {\n\t\t\t\t// The top state is not an ancestor of oNewState and is not preserved --> we can pop it\n\t\t\t\toLastRemovedItem = this._oManagedHistory.pop();\n\t\t\t\tiPopCount++;\n\t\t\t} else if (oTopState.preserved && removeAppStateInHash(oTopState.hash) === removeAppStateInHash(oNewState.hash)) {\n\t\t\t\t// We try to add a state that is already in cache (due to preserved flag) but with a different iapp-state\n\t\t\t\t// --> we should delete the previous entry (it will be later replaced by the new one) and stop popping\n\t\t\t\toLastRemovedItem = this._oManagedHistory.pop();\n\t\t\t\tiPopCount++;\n\t\t\t\toNewState.preserved = true;\n\t\t\t\tbreak;\n\t\t\t} else {\n\t\t\t\tbreak; // Ancestor or preserved state found --> we stop popping out states\n\t\t\t}\n\t\t}\n\n\t\t// 4. iAppState management\n\t\tthis.sIAppStateKey = this.findAppStateInHash(oNewState.hash);\n\t\tif (!this.fclEnabled && oLastRemovedItem) {\n\t\t\tconst sPreviousIAppStateKey = this.findAppStateInHash(oLastRemovedItem.hash);\n\t\t\tconst oComparisonStateResult = this._compareCacheStates(oLastRemovedItem, oNewState);\n\t\t\t// if current state doesn't contain a i-appstate and this state should replace a state containing a iAppState\n\t\t\t// then the previous iAppState is preserved\n\t\t\tif (\n\t\t\t\t!this.sIAppStateKey &&\n\t\t\t\tsPreviousIAppStateKey &&\n\t\t\t\t(oComparisonStateResult === enumState.EQUAL || oComparisonStateResult === enumState.COMPATIBLE)\n\t\t\t) {\n\t\t\t\toNewState.hash = this.setAppStateInHash(oNewState.hash, sPreviousIAppStateKey);\n\t\t\t}\n\t\t}\n\n\t\t// 5. Now we can push the state at the top of the internal history\n\t\tconst bHasSameHash = oLastRemovedItem && oNewState.hash === oLastRemovedItem.hash;\n\t\tif (this._oManagedHistory.length === 0 || this._oManagedHistory[this._oManagedHistory.length - 1].hash !== oNewState.hash) {\n\t\t\tthis._oManagedHistory.push(oNewState);\n\t\t\tif (oLastRemovedItem && removeAppStateInHash(oLastRemovedItem.hash) === removeAppStateInHash(oNewState.hash)) {\n\t\t\t\toNewState.focusControlId = oLastRemovedItem.focusControlId;\n\t\t\t\toNewState.secondaryFocusControlId = oLastRemovedItem.secondaryFocusControlId;\n\t\t\t\toNewState.focusInfo = oLastRemovedItem.focusInfo;\n\t\t\t\toNewState.secondaryFocusInfo = oLastRemovedItem.secondaryFocusInfo;\n\t\t\t}\n\t\t}\n\n\t\t// 6. Determine which actions to do on the history\n\t\tif (iPopCount === 0) {\n\t\t\t// No state was popped --> append\n\t\t\treturn { type: \"append\" };\n\t\t} else if (iPopCount === 1) {\n\t\t\t// Only 1 state was popped --> replace current hash unless hash is the same (then nothing to do)\n\t\t\treturn bHasSameHash ? { type: \"none\" } : { type: \"replace\" };\n\t\t} else {\n\t\t\t// More than 1 state was popped --> go bakc in history and replace hash if necessary\n\t\t\treturn bHasSameHash ? { type: \"back\", steps: iPopCount - 1 } : { type: \"back-replace\", steps: iPopCount - 1 };\n\t\t}\n\t}\n\n\t_blockingNavigationFilter(): \"Custom\" | \"Continue\" {\n\t\treturn this._bDisableOnHashChange ? \"Custom\" : \"Continue\";\n\t}\n\n\t/**\n\t * Disable the routing by calling the router stop method.\n\t * @final\n\t */\n\t_disableEventOnHashChange(): void {\n\t\tthis._bDisableOnHashChange = true;\n\t\tthis._oRouter.stop();\n\t}\n\n\t/**\n\t * Enable the routing by calling the router initialize method.\n\t * @param [bIgnoreCurrentHash] Ignore the last hash event triggered before the router has initialized\n\t * @final\n\t */\n\t_enableEventOnHashChange(bIgnoreCurrentHash: boolean | undefined): void {\n\t\tthis._bDisableOnHashChange = false;\n\t\tthis._oRouter.initialize(bIgnoreCurrentHash);\n\t}\n\n\t/**\n\t * Synchronizes the browser history with the internal history of the routerProxy, and triggers a navigation if needed.\n\t * @param oHistoryAction Specifies the navigation action to be performed\n\t * @param bRebuildOnly `true` if internal history is currently being rebuilt\n\t * @returns Promise (resolved when the navigation is finalized) that returns 'true' if a navigation took place, 'false' if the navigation didn't happen\n\t * @final\n\t */\n\tasync _rebuildBrowserHistory(oHistoryAction: HystoryAction, bRebuildOnly: boolean): Promise<boolean> {\n\t\t// eslint-disable-next-line @typescript-eslint/no-this-alias\n\t\tconst that = this;\n\t\treturn new Promise((resolve) => {\n\t\t\tthis.bIsRebuildHistoryRunning = true;\n\t\t\tconst oTargetState = this._oManagedHistory[this._oManagedHistory.length - 1],\n\t\t\t\tnewLevel = this._oManagedHistory.length - 1;\n\n\t\t\tfunction replaceAsync(): void {\n\t\t\t\tif (!bRebuildOnly) {\n\t\t\t\t\tthat._enableEventOnHashChange(true);\n\t\t\t\t}\n\n\t\t\t\t(that._oRouter.getHashChanger().replaceHash as Function)(oTargetState.hash);\n\t\t\t\thistory.replaceState(Object.assign({ feLevel: newLevel }, history.state), \"\");\n\n\t\t\t\tif (bRebuildOnly) {\n\t\t\t\t\tsetTimeout(function () {\n\t\t\t\t\t\t// Timeout to let 'hashchange' event be processed before by the HashChanger, so that\n\t\t\t\t\t\t// onRouteMatched notification isn't raised\n\t\t\t\t\t\tthat._enableEventOnHashChange(true);\n\t\t\t\t\t}, 0);\n\t\t\t\t}\n\n\t\t\t\tthat.bIsRebuildHistoryRunning = false;\n\t\t\t\tresolve(true); // a navigation occurred\n\t\t\t}\n\n\t\t\t// Async callbacks when navigating back, in order to let all notifications and events get processed\n\t\t\tfunction backReplaceAsync(): void {\n\t\t\t\twindow.removeEventListener(\"popstate\", backReplaceAsync);\n\t\t\t\tsetTimeout(function () {\n\t\t\t\t\t// Timeout to let 'hashchange' event be processed before by the HashChanger\n\t\t\t\t\treplaceAsync();\n\t\t\t\t}, 0);\n\t\t\t}\n\n\t\t\tfunction backAsync(): void {\n\t\t\t\twindow.removeEventListener(\"popstate\", backAsync);\n\t\t\t\tthat.bIsRebuildHistoryRunning = false;\n\t\t\t\tresolve(true); // a navigation occurred\n\t\t\t}\n\n\t\t\tthat._bIgnoreRestore = true;\n\n\t\t\tswitch (oHistoryAction.type) {\n\t\t\t\tcase \"replace\":\n\t\t\t\t\tconst focusInfo = history.state?.focusInfo;\n\t\t\t\t\t(that._oRouter.getHashChanger().replaceHash as Function)(oTargetState.hash);\n\t\t\t\t\thistory.replaceState(\n\t\t\t\t\t\tObject.assign(\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tfeLevel: newLevel,\n\t\t\t\t\t\t\t\tfocusInfo: focusInfo\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\thistory.state\n\t\t\t\t\t\t),\n\t\t\t\t\t\t\"\"\n\t\t\t\t\t);\n\t\t\t\t\tthat.bIsRebuildHistoryRunning = false;\n\t\t\t\t\tresolve(true); // a navigation occurred\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"append\":\n\t\t\t\t\tthat._oRouter.getHashChanger().setHash(oTargetState.hash);\n\t\t\t\t\thistory.replaceState(Object.assign({ feLevel: newLevel }, history.state), \"\");\n\t\t\t\t\tthat.bIsRebuildHistoryRunning = false;\n\t\t\t\t\tresolve(true); // a navigation occurred\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"back\":\n\t\t\t\t\twindow.addEventListener(\"popstate\", backAsync);\n\t\t\t\t\thistory.go(-oHistoryAction.steps);\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"back-replace\":\n\t\t\t\t\tthis._disableEventOnHashChange();\n\t\t\t\t\twindow.addEventListener(\"popstate\", backReplaceAsync);\n\t\t\t\t\thistory.go(-oHistoryAction.steps);\n\t\t\t\t\tbreak;\n\n\t\t\t\tdefault:\n\t\t\t\t\t// No navigation\n\t\t\t\t\tthis.bIsRebuildHistoryRunning = false;\n\t\t\t\t\tresolve(false); // no navigation --> resolve to false\n\t\t\t}\n\t\t});\n\t}\n\n\tgetLastHistoryEntry(): RouterState {\n\t\treturn this._oManagedHistory[this._oManagedHistory.length - 1];\n\t}\n\n\tsetPathMapping(mappings: { oldPath: string; newPath: string }[]): void {\n\t\tthis._pathMappings = mappings.filter((mapping) => {\n\t\t\treturn mapping.oldPath !== mapping.newPath;\n\t\t});\n\t}\n\n\thashGuard(): void {\n\t\tlet sHash = this.getDecodedWindowHash();\n\t\tconst currentAppName = this.getAppNameFromHash(sHash);\n\t\tif (currentAppName != this.appName) {\n\t\t\t// When doing external navigation in another window, the current window location is temporarily modified with the URL of the target app\n\t\t\t// In this case, we don't want to update the internally managed history, so we simply do nothing\n\t\t\treturn;\n\t\t}\n\n\t\tif (sHash.includes(\"restoreHistory=true\")) {\n\t\t\tthis._bApplyRestore = true;\n\t\t} else if (!this.bIsRebuildHistoryRunning && this._oRouter.isInitialized()) {\n\t\t\t// Check if the hash needs to be changed (this happens in FCL when switching b/w edit and read-only with 3 columns open)\n\t\t\tconst mapping = this._pathMappings.find((m) => {\n\t\t\t\treturn sHash.includes(m.oldPath);\n\t\t\t});\n\t\t\tif (mapping) {\n\t\t\t\t// Replace the current hash\n\t\t\t\tsHash = sHash.replace(mapping.oldPath, mapping.newPath);\n\t\t\t\thistory.replaceState(Object.assign({}, history.state), \"\", encodeURI(sHash));\n\t\t\t}\n\n\t\t\tconst aHashSplit = sHash.split(\"&/\");\n\t\t\tconst sAppHash = aHashSplit[1] ? aHashSplit[1] : \"\";\n\t\t\tif (this.checkHashWithGuard(sAppHash)) {\n\t\t\t\tconst oNewState = this._extractStateFromHash(sAppHash);\n\t\t\t\tthis._pushNewState(oNewState, false, false, this.isAppStateUpdating() ? false : true);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Compares 2 states.\n\t * @param {object} oState1\n\t * @param {object} oState2\n\t * @returns {number} The result of the comparison:\n\t *        - enumState.EQUAL if oState1 and oState2 are equal\n\t *        - enumState.COMPATIBLE if oState1 and oState2 are compatible\n\t *        - enumState.ANCESTOR if oState1 is an ancestor of oState2\n\t *        - enumState.DIFFERENT if the 2 states are different\n\t */\n\n\t_compareCacheStates(oState1: RouterState, oState2: RouterState): number {\n\t\t// First compare object keys\n\t\tif (oState1.keys.length > oState2.keys.length) {\n\t\t\treturn enumState.DIFFERENT;\n\t\t}\n\t\tlet equal = true;\n\t\tlet index;\n\n\t\tfor (index = 0; equal && index < oState1.keys.length; index++) {\n\t\t\tif (oState1.keys[index] !== oState2.keys[index]) {\n\t\t\t\tequal = false;\n\t\t\t}\n\t\t}\n\n\t\tif (!equal) {\n\t\t\t// Check routingHints\n\t\t\tif (oState1.keys.length === 1 && oState2.keys.length === 1 && this.routingHints?.[oState1.keys[0]]) {\n\t\t\t\tif (this.routingHints[oState1.keys[0]].parentOf && this.routingHints[oState1.keys[0]].parentOf.includes(oState2.keys[0])) {\n\t\t\t\t\treturn enumState.ANCESTOR;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Some objects keys are different\n\t\t\treturn enumState.DIFFERENT;\n\t\t}\n\n\t\t// All keys from oState1 are in oState2 --> check if ancestor\n\t\tif (oState1.keys.length < oState2.keys.length || oState1.screenMode < oState2.screenMode) {\n\t\t\treturn enumState.ANCESTOR;\n\t\t}\n\t\tif (oState1.screenMode > oState2.screenMode) {\n\t\t\treturn enumState.DIFFERENT; // Not sure this case can happen...\n\t\t}\n\n\t\t// At this stage, the 2 states have the same object keys (in the same order) and same screenmode\n\t\t// They can be either compatible or equal\n\t\treturn oState1.sLayout === oState2.sLayout ? enumState.EQUAL : enumState.COMPATIBLE;\n\t}\n\n\t/**\n\t * Split the app-specific route at the \"&/\" separator.\n\t *\n\t * The app-specific route consists of one or more segments separated by \"&/\".\n\t * @example\n\t * splitAppSpecificRoute(\"&/Entity('abc')/NextEntity('xyz')\");\n\t * // [\"Entity('abc')/NextEntity('xyz')\"]\n\t *\n\t * splitAppSpecificRoute(\"&/Entity('abc')/NextEntity('xyz')&/Prefix/NestedRoute\");\n\t * // [\"Entity('abc')/NextEntity('xyz')\", \"Prefix/NestedRoute\"]\n\t * @param appSpecificRoute\tThe app-specific route.\n\t * @returns An array of app-specific route segments.\n\t */\n\tprivate static splitAppSpecificRoute(appSpecificRoute: string | undefined): string[] {\n\t\tconst routeSplit = appSpecificRoute?.split(\"&/\") ?? [];\n\t\tif (!routeSplit[0]) {\n\t\t\trouteSplit.shift(); // remove the leading empty segment (the app-specific route starts with \"&/\")\n\t\t}\n\t\treturn routeSplit;\n\t}\n\n\t/**\n\t * Checks if back exits the present guard set.\n\t * @returns `true` if back exits the guard\n\t */\n\tcheckIfBackIsOutOfGuard(): boolean {\n\t\t// We use window.location.hash instead of HashChanger.getInstance().getHash() because the latter\n\t\t// replaces characters in the URL (e.g. %24 replaced by $) and it causes issues when comparing\n\t\t// with the URLs in the managed history\n\t\tconst splitHash = this.getFullHash();\n\n\t\tconst segments = RouterProxy.splitAppSpecificRoute(splitHash);\n\n\t\tif (segments.length > 1) {\n\t\t\t// there is a nested route involved -> assume we are still inside the guard\n\t\t\treturn false;\n\t\t}\n\n\t\tconst hash = segments[0] ?? \"\";\n\n\t\tlet previousHash;\n\t\tif (this._oNavigationGuard) {\n\t\t\tfor (let i = this._oManagedHistory.length - 1; i > 0; i--) {\n\t\t\t\tif (this._oManagedHistory[i].hash === hash) {\n\t\t\t\t\tpreviousHash = this._oManagedHistory[i - 1].hash;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn !previousHash || !this.checkHashWithGuard(previousHash);\n\t\t}\n\t\treturn false;\n\t}\n\n\t/**\n\t * Checks if a back navigation will exit the app.\n\t * @returns True if back exits the app\n\t */\n\tcheckIfBackExitsApp(): boolean {\n\t\tconst splitHash = this.getFullHash();\n\n\t\tconst segments = RouterProxy.splitAppSpecificRoute(splitHash);\n\n\t\tif (segments.length > 1) {\n\t\t\t// there is a nested route involved -> assume we are still inside the app\n\t\t\treturn false;\n\t\t}\n\n\t\t// If the current hash is the first one in the history, then a navback will exit the app\n\t\tconst hash = segments[0] ?? \"\";\n\t\treturn this._oManagedHistory.length > 0 && this._oManagedHistory[0].hash === hash;\n\t}\n\n\t/**\n\t * Checks if the last 2 entries in the history share the same context.\n\t * @returns `true` if they share the same context.\n\t */\n\tcheckIfBackHasSameContext(): boolean {\n\t\tif (this._oManagedHistory.length < 2) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst oCurrentState = this._oManagedHistory[this._oManagedHistory.length - 1];\n\t\tconst oPreviousState = this._oManagedHistory[this._oManagedHistory.length - 2];\n\n\t\treturn oCurrentState.hash.split(\"?\")[0] === oPreviousState.hash.split(\"?\")[0];\n\t}\n\n\t/**\n\t * Restores the focus for the current hash, if we can find it in the history.\n\t * @returns True if focus was set, false otherwise.\n\t */\n\trestoreFocusForCurrentHash(): boolean {\n\t\tconst currentHash = removeAppStateInHash(this.getHash());\n\t\tconst stateForHash = this._oManagedHistory.find((state) => {\n\t\t\treturn removeAppStateInHash(state.hash) === currentHash;\n\t\t});\n\n\t\tlet focusApplied = false;\n\t\tif (stateForHash?.focusControlId) {\n\t\t\tlet focusControl = Element.getElementById(stateForHash.focusControlId);\n\t\t\tlet focusInfo = stateForHash.focusInfo;\n\t\t\tlet useSecondary = false;\n\t\t\tif ((!focusControl || !focusControl.getFocusDomRef()) && stateForHash.secondaryFocusControlId) {\n\t\t\t\t// The control for focus is either not found or is not displayed on screen (no focusDomRef)\n\t\t\t\t// --> try the secondary control if there's one\n\t\t\t\tfocusControl = Element.getElementById(stateForHash.secondaryFocusControlId);\n\t\t\t\tfocusInfo = stateForHash.secondaryFocusInfo;\n\t\t\t\tuseSecondary = true;\n\t\t\t}\n\t\t\tif (\n\t\t\t\t// if the control is a busy table, we don't want to focus it\n\t\t\t\t// tables have their own handling to restore focus, so we don't want to interfere with that\n\t\t\t\t// unless the table was a secondary control, where we want to focus on it anyway\n\t\t\t\tfocusControl?.getParent()?.isA<Table>(\"sap.ui.mdc.Table\") &&\n\t\t\t\t(focusControl as MTable | UITable).getBusy() &&\n\t\t\t\t!useSecondary\n\t\t\t) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tfocusControl?.focus(focusInfo);\n\t\t\tfocusApplied = focusControl !== undefined;\n\t\t}\n\n\t\treturn focusApplied;\n\t}\n\n\t/**\n\t * Stores the ID of the currently focused control in the history for the current hash.\n\t *\n\t */\n\tprivate storeFocusInfoForCurrentHash(): void {\n\t\tconst currentHash = removeAppStateInHash(this.getHash());\n\t\tconst stateForHash = this._oManagedHistory.find((state) => {\n\t\t\treturn removeAppStateInHash(state.hash) === currentHash;\n\t\t});\n\t\tif (stateForHash) {\n\t\t\tconst focusControl = Element.getActiveElement();\n\t\t\tstateForHash.focusControlId = focusControl?.getId();\n\t\t\tif (focusControl) {\n\t\t\t\t// The secondary focus control is the parent table if there's one\n\t\t\t\tlet parentTable = focusControl.getParent();\n\t\t\t\twhile (parentTable && !parentTable.isA<UITable>(\"sap.ui.table.Table\") && !parentTable.isA<MTable>(\"sap.m.Table\")) {\n\t\t\t\t\tparentTable = parentTable.getParent();\n\t\t\t\t}\n\t\t\t\tstateForHash.secondaryFocusControlId = parentTable?.getId();\n\t\t\t\tstateForHash.secondaryFocusInfo = { preventScroll: true };\n\t\t\t}\n\t\t\tstateForHash.focusInfo = focusControl?.getFocusInfo();\n\t\t}\n\t}\n\n\t/**\n\t * Finds a layout value for a hash in the history.\n\t * @param hash The hash to look for in the history.\n\t * @returns A layout value if it could be found, undefined otherwise.\n\t */\n\tfindLayoutForHash(hash: string): string | undefined {\n\t\tif (!this.fclEnabled) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Remove all query parameters from the hash\n\t\tconst hashNoParam = hash.split(\"?\")[0];\n\n\t\t// Look for the state backwards, so that we find the last state in the history (e.g. if we have 2 states with the same hash but 2 different layouts)\n\t\tlet targetState: RouterState | undefined;\n\t\tfor (let index = this._oManagedHistory.length - 1; index >= 0 && targetState === undefined; index--) {\n\t\t\tif (this._oManagedHistory[index].hash.split(\"?\")[0] === hashNoParam) {\n\t\t\t\ttargetState = this._oManagedHistory[index];\n\t\t\t}\n\t\t}\n\n\t\treturn targetState?.sLayout;\n\t}\n}\n\nexport default RouterProxy;\n"],"mappings":"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","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["enumState","EQUAL","COMPATIBLE","ANCESTOR","DIFFERENT","enumURLParams","LAYOUTPARAM","IAPPSTATEPARAM","createGuardFromHash","sGuardHash","hashTraker","_guardHash","replace","hashTracker","undefined","check","sHash","indexOf","removeAppStateInHash","RegExp","RouterProxy","_dec","defineUI5Class","_class","_BaseObject","_this","_len","arguments","length","args","Array","_key","call","bIsRebuildHistoryRunning","bIsComputingTitleHierachy","bIsGuardCrossAllowed","sIAppStateKey","_bActivateRouteMatchSynchro","_bApplyRestore","_pathMappings","restoreHistoryTriggered","appStateUpdating","_inheritsLoose","_proto","prototype","init","oAppComponent","isfclEnabled","getService","then","asyncInit","catch","oError","Log","error","_fnHashGuard","hashGuard","bind","window","addEventListener","_bDisableOnHashChange","_bIgnoreRestore","_bForceFocus","_oShellServices","getShellServices","initRaw","getRouter","routingHints","getRoutingService","getRoutingHints","waitForRouteMatchBeforeNavigation","history","replaceState","Object","assign","feLevel","state","location","fclEnabled","_fnBlockingNavFilter","_blockingNavigationFilter","registerNavigationFilter","destroy","unregisterNavigationFilter","removeEventListener","setAppStateInHash","sAppStateKey","sNewHash","includes","findAppStateInHash","aAppState","match","getDecodedWindowHash","decodeURI","hash","oRouter","_oRouter","_oManagedHistory","_oNavigationGuard","sCurrentAppHash","getHash","push","_extractStateFromHash","appName","getAppNameFromHash","getFullHash","splitHash","appSpecificRoute","getHashChanger","shellPart","isFocusForced","setFocusForced","bForced","removeIAppStateKey","setAppStateUpdating","updatingAppState","isAppStateUpdating","removeRestoreHistoryFlagFromHash","navToHash","bPreserveHistory","bDisablePreservationCache","bForceFocus","preserveShellBackNavigationHandler","skipHashGuardCheck","startsWith","substring","setBackNavigation","_oRouteMatchSynchronization","waitFor","_internalNavToHash","checkHashWithGuard","oResourceBundle","Library","getResourceBundleFor","confirm","getText","Promise","resolve","oNewState","aCurrentHashKeys","extractEntitySetsFromHash","keys","every","key","index","oHistoryAction","_pushNewState","storeFocusInfoForCurrentHash","_rebuildBrowserHistory","restoreHistory","sTargetHash","checkRestoreHistoryWasTriggered","resetRestoreHistoryFlag","navBack","sCurrentHash","sPreviousHash","i","back","navTo","sRouteName","oParameters","getURL","noPreservationCache","bIsStickyMode","isHiddenDraftEnabled","exitFromApp","backToPreviousApp","isCurrentStateImpactedBy","oLocalGuard","isNavigationFinalized","setNavigationGuard","discardNavigationGuard","hasNavigationGuard","isGuardCrossAllowedByUser","activateRouteMatchSynchronization","resolveRouteMatch","Synchronization","sHashNoParams","split","aTokens","names","forEach","sToken","oState","screenMode","aLayout","sLayout","bRebuildOnly","bDisableHistoryPreservation","lastIndex","iPopCount","pop","preserved","oLastRemovedItem","oTopState","_compareCacheStates","sPreviousIAppStateKey","oComparisonStateResult","bHasSameHash","focusControlId","secondaryFocusControlId","focusInfo","secondaryFocusInfo","type","steps","_disableEventOnHashChange","stop","_enableEventOnHashChange","bIgnoreCurrentHash","initialize","that","oTargetState","newLevel","replaceAsync","replaceHash","setTimeout","backReplaceAsync","backAsync","setHash","go","getLastHistoryEntry","setPathMapping","mappings","filter","mapping","oldPath","newPath","currentAppName","isInitialized","find","m","encodeURI","aHashSplit","sAppHash","oState1","oState2","equal","parentOf","splitAppSpecificRoute","routeSplit","shift","checkIfBackIsOutOfGuard","segments","previousHash","checkIfBackExitsApp","checkIfBackHasSameContext","oCurrentState","oPreviousState","restoreFocusForCurrentHash","currentHash","stateForHash","focusApplied","focusControl","Element","getElementById","useSecondary","getFocusDomRef","getParent","isA","getBusy","focus","getActiveElement","getId","parentTable","preventScroll","getFocusInfo","findLayoutForHash","hashNoParam","targetState","BaseObject"],"sourceRoot":".","sources":["RouterProxy.ts"],"sourcesContent":["import Log from \"sap/base/Log\";\nimport type ResourceBundle from \"sap/base/i18n/ResourceBundle\";\nimport { defineUI5Class } from \"sap/fe/base/ClassSupport\";\nimport type AppComponent from \"sap/fe/core/AppComponent\";\nimport Synchronization from \"sap/fe/core/helpers/Synchronization\";\nimport type { IShellServices } from \"sap/fe/core/services/ShellServicesFactory\";\nimport type MTable from \"sap/m/Table\";\nimport BaseObject from \"sap/ui/base/Object\";\nimport Element from \"sap/ui/core/Element\";\nimport Library from \"sap/ui/core/Lib\";\nimport type Router from \"sap/ui/core/routing/Router\";\nimport type Table from \"sap/ui/mdc/Table\";\nimport type UITable from \"sap/ui/table/Table\";\n\nconst enumState = {\n\tEQUAL: 0,\n\tCOMPATIBLE: 1,\n\tANCESTOR: 2,\n\tDIFFERENT: 3\n};\nconst enumURLParams = {\n\tLAYOUTPARAM: \"layout\",\n\tIAPPSTATEPARAM: \"sap-iapp-state\"\n};\n\ntype RouterState = {\n\tkeys: string[];\n\thash: string;\n\tpreserved?: boolean;\n\tsLayout?: string;\n\tscreenMode: number;\n\tfocusControlId?: string;\n\tsecondaryFocusControlId?: string;\n\tfocusInfo?: {\n\t\tpreventScroll?: boolean;\n\t\ttargetInfo?: unknown;\n\t};\n\tsecondaryFocusInfo?: {\n\t\tpreventScroll?: boolean;\n\t};\n};\n\ntype OtherHistoryAction = { type: \"append\" | \"none\" | \"replace\" };\nexport type BackHistoryAction = { type: \"back\" | \"back-replace\"; steps: number };\ntype HystoryAction = BackHistoryAction | OtherHistoryAction;\n\ntype NavigationGuard = { _guardHash: string; hashTracker: string | undefined; check: (hash: string) => boolean };\n/**\n * Creates a HashGuard object.\n * @param sGuardHash The hash used for the guard.\n * @param [hashTraker] Optional hash tracker used for additional guard checks.\n * @returns The created hash guard.\n */\nfunction createGuardFromHash(sGuardHash: string, hashTraker?: string): NavigationGuard {\n\treturn {\n\t\t_guardHash: sGuardHash.replace(/\\?[^?]*$/, \"\"), // Remove query part\n\t\thashTracker: hashTraker ? hashTraker.replace(/\\?[^?]*$/, \"\") : undefined,\n\t\tcheck: function (sHash: string): boolean {\n\t\t\treturn sHash.indexOf(this._guardHash) === 0 || (this.hashTracker ? sHash.indexOf(this.hashTracker) === 0 : false);\n\t\t}\n\t};\n}\n/**\n * Returns a hash without its iAppState part.\n * @param sHash The hash\n * @returns The hash without the iAppState\n */\nfunction removeAppStateInHash(sHash: string): string {\n\treturn sHash.replace(new RegExp(`[&?]*${enumURLParams.IAPPSTATEPARAM}=[^&]*`), \"\");\n}\n\n@defineUI5Class(\"sap.fe.core.RouterProxy\")\nclass RouterProxy extends BaseObject {\n\tbIsRebuildHistoryRunning = false;\n\n\tbIsComputingTitleHierachy = false;\n\n\tbIsGuardCrossAllowed = false;\n\n\tsIAppStateKey: string | null = null;\n\n\t_oShellServices!: IShellServices;\n\n\tfclEnabled!: boolean;\n\n\t_fnBlockingNavFilter!: Function;\n\n\t_fnHashGuard!: (this: Window, popStateEvent: PopStateEvent) => unknown;\n\n\t_bDisableOnHashChange!: boolean;\n\n\t_bIgnoreRestore!: boolean;\n\n\t_bForceFocus!: boolean;\n\n\t_oRouter!: Router;\n\n\t_oManagedHistory!: RouterState[];\n\n\t_oNavigationGuard!: NavigationGuard | null;\n\n\toResourceBundle?: ResourceBundle;\n\n\t_oRouteMatchSynchronization?: Synchronization;\n\n\t_bActivateRouteMatchSynchro = false;\n\n\t_bApplyRestore = false;\n\n\t_pathMappings: { oldPath: string; newPath: string }[] = [];\n\n\trestoreHistoryTriggered = false;\n\n\troutingHints?: Record<string, { parentOf: string[] }>;\n\n\tappName!: string;\n\n\tappStateUpdating = false;\n\n\tinit(oAppComponent: AppComponent, isfclEnabled: boolean): void {\n\t\t// Save the name of the app (including startup parameters) for rebuilding full hashes later\n\t\toAppComponent\n\t\t\t.getService(\"shellServices\")\n\t\t\t.then(() => this.asyncInit(oAppComponent, isfclEnabled))\n\t\t\t.catch(function (oError: unknown) {\n\t\t\t\tLog.error(\"Cannot retrieve the shell services\", oError as string);\n\t\t\t});\n\t\tthis._fnHashGuard = this.hashGuard.bind(this);\n\t\twindow.addEventListener(\"popstate\", this._fnHashGuard);\n\t\tthis._bDisableOnHashChange = false;\n\t\tthis._bIgnoreRestore = false;\n\t\tthis._bForceFocus = true; // Trigger the focus mechanism for the first view displayed by the app\n\t}\n\n\tasyncInit(oAppComponent: AppComponent, isfclEnabled: boolean): void {\n\t\tthis._oShellServices = oAppComponent.getShellServices();\n\t\tthis.initRaw(oAppComponent.getRouter());\n\t\tthis.routingHints = oAppComponent.getRoutingService().getRoutingHints();\n\t\t// We want to wait until the initial routeMatched is done before doing any navigation\n\t\tthis.waitForRouteMatchBeforeNavigation();\n\n\t\t// Set feLevel=0 for the first Application page in the history\n\t\thistory.replaceState(\n\t\t\tObject.assign(\n\t\t\t\t{\n\t\t\t\t\tfeLevel: 0\n\t\t\t\t},\n\t\t\t\thistory.state\n\t\t\t),\n\t\t\t\"\",\n\t\t\twindow.location as unknown as string\n\t\t);\n\t\tthis.fclEnabled = isfclEnabled;\n\n\t\tthis._fnBlockingNavFilter = this._blockingNavigationFilter.bind(this);\n\t\tthis._oShellServices.registerNavigationFilter(this._fnBlockingNavFilter);\n\t}\n\n\tdestroy(): void {\n\t\tif (this._oShellServices) {\n\t\t\tthis._oShellServices.unregisterNavigationFilter(this._fnBlockingNavFilter);\n\t\t}\n\t\twindow.removeEventListener(\"popstate\", this._fnHashGuard);\n\t}\n\n\t/**\n\t * Adds an iAppState inside a hash (or replaces an existing one).\n\t * @param sHash The hash\n\t * @param sAppStateKey The iAppState to add\n\t * @returns The hash with the app state\n\t */\n\tsetAppStateInHash(sHash: string, sAppStateKey: string): string {\n\t\tlet sNewHash: string;\n\n\t\tif (sHash.includes(enumURLParams.IAPPSTATEPARAM)) {\n\t\t\t// If there's already an iAppState parameter in the hash, replace it\n\t\t\tsNewHash = sHash.replace(\n\t\t\t\tnew RegExp(`${enumURLParams.IAPPSTATEPARAM}=[^&]*`),\n\t\t\t\t`${enumURLParams.IAPPSTATEPARAM}=${sAppStateKey}`\n\t\t\t);\n\t\t} else {\n\t\t\t// Add the iAppState parameter in the hash\n\t\t\tif (!sHash.includes(\"?\")) {\n\t\t\t\tsNewHash = `${sHash}?`;\n\t\t\t} else {\n\t\t\t\tsNewHash = `${sHash}&`;\n\t\t\t}\n\t\t\tsNewHash += `${enumURLParams.IAPPSTATEPARAM}=${sAppStateKey}`;\n\t\t}\n\n\t\treturn sNewHash;\n\t}\n\n\t/**\n\t * Returns the iAppState part from a hash (or null if not found).\n\t * @param sHash The hash\n\t * @returns The iAppState part of the hash\n\t */\n\tfindAppStateInHash(sHash: string): string | null {\n\t\tconst aAppState = sHash.match(new RegExp(`\\\\?.*${enumURLParams.IAPPSTATEPARAM}=([^&]*)`));\n\t\treturn aAppState && aAppState.length > 1 ? aAppState[1] : null;\n\t}\n\n\tprivate getDecodedWindowHash(): string {\n\t\treturn decodeURI(window.location.hash);\n\t}\n\n\t/**\n\t * Raw initialization (for unit tests).\n\t * @param oRouter The router used by this proxy\n\t */\n\tinitRaw(oRouter: Router): void {\n\t\tthis._oRouter = oRouter;\n\t\tthis._oManagedHistory = [];\n\t\tthis._oNavigationGuard = null;\n\n\t\tconst sCurrentAppHash = this.getHash();\n\t\tthis._oManagedHistory.push(this._extractStateFromHash(sCurrentAppHash));\n\n\t\tthis.appName = this.getAppNameFromHash(this.getDecodedWindowHash());\n\n\t\t// Set the iAppState if the initial hash contains one\n\t\tthis.sIAppStateKey = this.findAppStateInHash(sCurrentAppHash);\n\t}\n\n\t/**\n\t * Return the full app-specific hash part from window.location.hash.\n\t *\n\t * Compared to {@link getHash} this function includes sub-routes of nested components.\n\t * @returns The app-specific hash part (i.e., without the shell part), or an empty string if there is none.\n\t */\n\tgetFullHash(): string {\n\t\tconst splitHash = this._oShellServices.splitHash(this.getDecodedWindowHash());\n\n\t\tif (\"appSpecificRoute\" in splitHash) {\n\t\t\treturn splitHash.appSpecificRoute?.replace(/^&\\//, \"\") ?? \"\"; // remove the leading \"&/\"\n\t\t}\n\t\treturn \"\";\n\t}\n\n\tgetHash(): string {\n\t\treturn this._oRouter.getHashChanger().getHash() ?? \"\";\n\t}\n\n\tprotected getAppNameFromHash(hash: string): string {\n\t\tconst splitHash = this._oShellServices?.splitHash(hash) as { shellPart: string; appSpecificRoute: string } | undefined;\n\t\treturn splitHash?.shellPart ?? \"\";\n\t}\n\n\tisFocusForced(): boolean {\n\t\treturn this._bForceFocus;\n\t}\n\n\tsetFocusForced(bForced: boolean): void {\n\t\tthis._bForceFocus = bForced;\n\t}\n\n\t/**\n\t * Resets the internal variable sIAppStateKey.\n\t *\n\t */\n\tremoveIAppStateKey(): void {\n\t\tthis.sIAppStateKey = null;\n\t}\n\n\tsetAppStateUpdating(updatingAppState: boolean): void {\n\t\tthis.appStateUpdating = updatingAppState;\n\t}\n\n\tisAppStateUpdating(): boolean {\n\t\treturn this.appStateUpdating;\n\t}\n\n\tprivate removeRestoreHistoryFlagFromHash(hash: string): string {\n\t\treturn hash.replace(\"restoreHistory=true&\", \"\").replace(/[?&]restoreHistory=true/, \"\");\n\t}\n\n\t/**\n\t * Navigates to a specific hash.\n\t * @param sHash Hash to be navigated to\n\t * @param bPreserveHistory If set to true, non-ancestor entries in history will be retained\n\t * @param bDisablePreservationCache If set to true, cache preservation mechanism is disabled for the current navigation\n\t * @param bForceFocus If set to true, the logic to set the focus once the navigation is finalized will be triggered (onPageReady)\n\t * @param preserveShellBackNavigationHandler If set to true, the back navigation callback is preserved. If undefined or false, the back navigation callback is reset.\n\t * @param skipHashGuardCheck\n\t * @returns Promise (resolved when the navigation is finalized) that returns 'true' if a navigation took place, 'false' if the navigation didn't happen\n\t */\n\tasync navToHash(\n\t\tsHash: string,\n\t\tbPreserveHistory?: boolean,\n\t\tbDisablePreservationCache?: boolean,\n\t\tbForceFocus?: boolean,\n\t\tpreserveShellBackNavigationHandler?: boolean,\n\t\tskipHashGuardCheck?: boolean\n\t): Promise<boolean> {\n\t\tsHash = sHash.startsWith(\"/\") ? sHash.substring(1) : sHash;\n\t\tif (!preserveShellBackNavigationHandler) {\n\t\t\tawait this._oShellServices.setBackNavigation();\n\t\t}\n\t\tsHash = this.removeRestoreHistoryFlagFromHash(sHash);\n\t\tif (this._oRouteMatchSynchronization) {\n\t\t\treturn this._oRouteMatchSynchronization.waitFor().then(async () => {\n\t\t\t\tthis._oRouteMatchSynchronization = undefined;\n\t\t\t\treturn this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus, skipHashGuardCheck);\n\t\t\t});\n\t\t} else {\n\t\t\tif (this._bActivateRouteMatchSynchro) {\n\t\t\t\tthis.waitForRouteMatchBeforeNavigation();\n\t\t\t}\n\t\t\treturn this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus, skipHashGuardCheck);\n\t\t}\n\t}\n\n\tasync _internalNavToHash(\n\t\tsHash: string,\n\t\tbPreserveHistory?: boolean,\n\t\tbDisablePreservationCache?: boolean,\n\t\tbForceFocus?: boolean,\n\t\tskipHashGuardCheck?: boolean\n\t): Promise<boolean> {\n\t\t// Add the app state in the hash if needed\n\t\tif (this.fclEnabled && this.sIAppStateKey && !this.findAppStateInHash(sHash)) {\n\t\t\tsHash = this.setAppStateInHash(sHash, this.sIAppStateKey);\n\t\t}\n\n\t\tif (!this.checkHashWithGuard(sHash) && !(skipHashGuardCheck ?? false)) {\n\t\t\tif (!this.oResourceBundle) {\n\t\t\t\tthis.oResourceBundle = Library.getResourceBundleFor(\"sap.fe.core\")!;\n\t\t\t}\n\n\t\t\t// We have to use a confirm here for UI consistency reasons, as with some scenarios\n\t\t\t// in the EditFlow we rely on a UI5 mechanism that displays a confirm dialog.\n\t\t\t// eslint-disable-next-line no-alert\n\t\t\tif (!confirm(this.oResourceBundle.getText(\"C_ROUTER_PROXY_SAPFE_EXIT_NOTSAVED_MESSAGE\"))) {\n\t\t\t\t// The user clicked on Cancel --> cancel navigation\n\t\t\t\treturn Promise.resolve(false);\n\t\t\t}\n\t\t\tthis.bIsGuardCrossAllowed = true;\n\t\t}\n\n\t\t// In case the navigation will cause a new view to be displayed, we force the focus\n\t\t// I.e. if the keys for the hash we're navigating to is a superset of the current hash keys.\n\t\tconst oNewState = this._extractStateFromHash(sHash);\n\t\tif (!this._bForceFocus) {\n\t\t\t// If the focus was already forced, keep it\n\t\t\tconst aCurrentHashKeys = RouterProxy.extractEntitySetsFromHash(this.getHash());\n\t\t\tthis._bForceFocus =\n\t\t\t\tbForceFocus ||\n\t\t\t\t(aCurrentHashKeys.length < oNewState.keys.length &&\n\t\t\t\t\taCurrentHashKeys.every(function (key: string, index: number) {\n\t\t\t\t\t\treturn key === oNewState.keys[index];\n\t\t\t\t\t}));\n\t\t}\n\n\t\tconst oHistoryAction = this._pushNewState(oNewState, false, bPreserveHistory, bDisablePreservationCache);\n\t\tthis.storeFocusInfoForCurrentHash();\n\n\t\treturn this._rebuildBrowserHistory(oHistoryAction, false);\n\t}\n\n\t/**\n\t * Clears browser history if entries have been added without using the RouterProxy.\n\t * Updates the internal history accordingly.\n\t * @returns Promise that is resolved once the history is rebuilt\n\t */\n\tasync restoreHistory(): Promise<void | boolean> {\n\t\tif (this._bApplyRestore) {\n\t\t\tthis._bApplyRestore = false;\n\t\t\tlet sTargetHash = this.getHash();\n\t\t\tsTargetHash = this.removeRestoreHistoryFlagFromHash(sTargetHash);\n\t\t\tconst oNewState = this._extractStateFromHash(sTargetHash);\n\n\t\t\tconst oHistoryAction = this._pushNewState(oNewState, true, false, true);\n\n\t\t\tthis.restoreHistoryTriggered = true;\n\t\t\treturn this._rebuildBrowserHistory(oHistoryAction, true);\n\t\t} else {\n\t\t\treturn Promise.resolve();\n\t\t}\n\t}\n\n\t/**\n\t * Checks if RestoreHistory has been triggered on the RouterProxy.\n\t * @returns True if it has been triggered\n\t */\n\tcheckRestoreHistoryWasTriggered(): boolean {\n\t\treturn this.restoreHistoryTriggered;\n\t}\n\n\t/**\n\t * Resets the flag that says if RestoreHistory has been triggered on the RouterProxy.\n\t */\n\tresetRestoreHistoryFlag(): void {\n\t\tthis.restoreHistoryTriggered = false;\n\t}\n\n\t/**\n\t * Navigates back in the history.\n\t * @returns Promise that is resolved when the navigation is finalized\n\t */\n\tasync navBack(): Promise<void | boolean> {\n\t\tconst sCurrentHash = this.getHash();\n\t\tlet sPreviousHash;\n\n\t\t// Look for the current hash in the managed history\n\t\tfor (let i = this._oManagedHistory.length - 1; i > 0; i--) {\n\t\t\tif (this._oManagedHistory[i].hash === sCurrentHash) {\n\t\t\t\tsPreviousHash = this._oManagedHistory[i - 1].hash;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif (sPreviousHash) {\n\t\t\treturn this.navToHash(sPreviousHash);\n\t\t} else {\n\t\t\t// We couldn't find a previous hash in history\n\t\t\t// This can happen when navigating from a transient hash in a create app, and\n\t\t\t// in that case history.back would go back to the FLP\n\t\t\twindow.history.back();\n\t\t\treturn Promise.resolve();\n\t\t}\n\t}\n\n\t/**\n\t * Navigates to a route with parameters.\n\t * @param sRouteName The route name to be navigated to\n\t * @param oParameters Parameters for the navigation\n\t * @param oParameters.noPreservationCache\n\t * @param oParameters.bIsStickyMode\n\t * @param oParameters.isHiddenDraftEnabled\n\t * @returns Promise that is resolved when the navigation is finalized\n\t */\n\tasync navTo(\n\t\tsRouteName: string,\n\t\toParameters?: { noPreservationCache?: boolean; bIsStickyMode?: boolean; isHiddenDraftEnabled?: boolean }\n\t): Promise<boolean> {\n\t\tconst sHash = this._oRouter.getURL(sRouteName, oParameters);\n\t\treturn this.navToHash(\n\t\t\tsHash!,\n\t\t\tfalse,\n\t\t\toParameters?.noPreservationCache,\n\t\t\tfalse,\n\t\t\t(oParameters?.bIsStickyMode ?? false) || (oParameters?.isHiddenDraftEnabled ?? false)\n\t\t);\n\t}\n\n\t/**\n\t * Exits the current app by navigating back\n\t * to the previous app (if any) or the FLP.\n\t * @returns Promise that is resolved when we exit the app\n\t */\n\texitFromApp(): void {\n\t\treturn this._oShellServices.backToPreviousApp();\n\t}\n\n\t/**\n\t * Checks whether a given hash can have an impact on the current state\n\t * i.e. if the hash is equal, compatible or an ancestor of the current state.\n\t * @param sHash `true` if there is an impact\n\t * @returns If there is an impact\n\t */\n\tisCurrentStateImpactedBy(sHash: string): boolean {\n\t\tif (sHash[0] === \"/\") {\n\t\t\tsHash = sHash.substring(1);\n\t\t}\n\t\tconst oLocalGuard = createGuardFromHash(sHash);\n\t\treturn oLocalGuard.check(this.getHash());\n\t}\n\n\t/**\n\t * Checks if a navigation is currently being processed.\n\t * @returns `false` if a navigation has been triggered in the RouterProxy and is not yet finalized\n\t */\n\tisNavigationFinalized(): boolean {\n\t\treturn !this.bIsRebuildHistoryRunning;\n\t}\n\n\t/**\n\t * Sets the last state as a guard.\n\t * Each future navigation will be checked against this guard, and a confirmation dialog will\n\t * be displayed before the navigation goes to an ancestor of the guard.\n\t * @param sHash The hash for the guard.\n\t * @param [hashTraker] Optional hash tracker used for additional guard checks.\n\t */\n\tsetNavigationGuard(sHash: string, hashTraker?: string): void {\n\t\tthis._oNavigationGuard = createGuardFromHash(sHash, hashTraker);\n\t\tthis.bIsGuardCrossAllowed = false;\n\t}\n\n\t/**\n\t * Disables the navigation guard.\n\t */\n\tdiscardNavigationGuard(): void {\n\t\tthis._oNavigationGuard = null;\n\t}\n\n\t/**\n\t * Checks for the availability of the navigation guard.\n\t * @returns `true` if navigating guard is available\n\t */\n\thasNavigationGuard(): boolean {\n\t\treturn this._oNavigationGuard !== null;\n\t}\n\n\t/**\n\t * Tests a hash against the navigation guard.\n\t * @param sHash The hash to be tested\n\t * @returns `true` if navigating to the hash doesn't cross the guard\n\t */\n\tcheckHashWithGuard(sHash: string): boolean {\n\t\treturn this._oNavigationGuard === null || this._oNavigationGuard.check(sHash);\n\t}\n\n\t/**\n\t * Checks if the user allowed the navigation guard to be crossed.\n\t * @returns `true` if crossing the guard has been allowed by the user\n\t */\n\tisGuardCrossAllowedByUser(): boolean {\n\t\treturn this.bIsGuardCrossAllowed;\n\t}\n\n\t/**\n\t * Activates the synchronization for routeMatchedEvent.\n\t * The next NavToHash call will create a Synchronization object that will be resolved\n\t * by the corresponding onRouteMatched event, preventing another NavToHash to happen in parallel.\n\t */\n\tactivateRouteMatchSynchronization(): void {\n\t\tthis._bActivateRouteMatchSynchro = true;\n\t}\n\n\t/**\n\t * Resolve the routeMatch synchronization object, unlocking potential pending NavToHash calls.\n\t */\n\tresolveRouteMatch(): void {\n\t\tif (this._oRouteMatchSynchronization) {\n\t\t\tthis._oRouteMatchSynchronization.resolve();\n\t\t}\n\t}\n\n\t/**\n\t * Makes sure no navigation can happen before a routeMatch happened.\n\t */\n\twaitForRouteMatchBeforeNavigation(): void {\n\t\tthis._oRouteMatchSynchronization = new Synchronization();\n\t\tthis._bActivateRouteMatchSynchro = false;\n\t}\n\n\tstatic extractEntitySetsFromHash(sHash: string | undefined): string[] {\n\t\tif (sHash === undefined) {\n\t\t\tsHash = \"\";\n\t\t}\n\t\tconst sHashNoParams = sHash.split(\"?\")[0]; // remove params\n\t\tconst aTokens = sHashNoParams.split(\"/\");\n\t\tconst names: string[] = [];\n\n\t\taTokens.forEach((sToken) => {\n\t\t\tif (sToken.length) {\n\t\t\t\tnames.push(sToken.split(\"(\")[0]);\n\t\t\t}\n\t\t});\n\n\t\treturn names;\n\t}\n\n\t/**\n\t * Builds a state from a hash.\n\t * @param sHash The hash to be used as entry\n\t * @returns The state\n\t */\n\t_extractStateFromHash(sHash: string): RouterState {\n\t\tif (sHash === undefined) {\n\t\t\tsHash = \"\";\n\t\t}\n\n\t\tconst oState: RouterState = {\n\t\t\tkeys: RouterProxy.extractEntitySetsFromHash(sHash),\n\t\t\thash: sHash,\n\t\t\tscreenMode: 0 // will be updated in a sec\n\t\t};\n\n\t\t// Retrieve layout (if any)\n\t\tconst aLayout = sHash.match(new RegExp(`\\\\?.*${enumURLParams.LAYOUTPARAM}=([^&]*)`));\n\t\toState.sLayout = aLayout && aLayout.length > 1 ? aLayout[1] : undefined;\n\t\tif (oState.sLayout === \"MidColumnFullScreen\") {\n\t\t\toState.screenMode = 1;\n\t\t} else if (oState.sLayout === \"EndColumnFullScreen\") {\n\t\t\toState.screenMode = 2;\n\t\t} else {\n\t\t\toState.screenMode = 0;\n\t\t}\n\t\treturn oState;\n\t}\n\n\t/**\n\t * Adds a new state into the internal history structure.\n\t * Makes sure this new state is added after an ancestor.\n\t * Also sets the iAppState key in the whole history.\n\t * @param oNewState The new state to be added\n\t * @param bRebuildOnly `true` if we're rebuilding the history after a shell menu navigation\n\t * @param bPreserveHistory If set to true, non-ancestor entries in history will be retained\n\t * @param bDisableHistoryPreservation Disable the mechanism to retained marked entries in cache\n\t * @returns The new state\n\t * @final\n\t */\n\t_pushNewState(\n\t\toNewState: RouterState,\n\t\tbRebuildOnly: boolean,\n\t\tbPreserveHistory?: boolean,\n\t\tbDisableHistoryPreservation?: boolean\n\t): HystoryAction {\n\t\tconst sCurrentHash = this.removeRestoreHistoryFlagFromHash(this.getHash());\n\t\tlet lastIndex = this._oManagedHistory.length - 1;\n\t\tlet iPopCount = bRebuildOnly ? 1 : 0;\n\n\t\t// 1. Do some cleanup in the managed history : in case the user has navigated back in the browser history, we need to remove\n\t\t// the states ahead in history and make sure the top state corresponds to the current page\n\t\t// We don't do that when restoring the history, as the current state has been added on top of the browser history\n\t\t// and is not reflected in the managed history\n\t\tif (!bRebuildOnly) {\n\t\t\twhile (lastIndex >= 0 && this._oManagedHistory[lastIndex].hash !== sCurrentHash) {\n\t\t\t\tthis._oManagedHistory.pop();\n\t\t\t\tlastIndex--;\n\t\t\t}\n\n\t\t\tif (this._oManagedHistory.length === 0) {\n\t\t\t\t// We couldn't find the current location in the history. This can happen if a browser reload\n\t\t\t\t// happened, causing a reinitialization of the managed history.\n\t\t\t\t// In that case, we use the current location as the new starting point in the managed history\n\t\t\t\tthis._oManagedHistory.push(this._extractStateFromHash(sCurrentHash));\n\t\t\t\thistory.replaceState(Object.assign({ feLevel: 0 }, history.state), \"\");\n\t\t\t}\n\t\t}\n\n\t\t// 2. Mark the top state as preserved if required\n\t\tif (bPreserveHistory && !bDisableHistoryPreservation) {\n\t\t\tthis._oManagedHistory[this._oManagedHistory.length - 1].preserved = true;\n\t\t}\n\n\t\t// 3. Then pop all states until we find an ancestor of the new state, or we find a state that need to be preserved\n\t\tlet oLastRemovedItem;\n\t\twhile (this._oManagedHistory.length > 0) {\n\t\t\tconst oTopState = this._oManagedHistory[this._oManagedHistory.length - 1];\n\t\t\tif (\n\t\t\t\t(bDisableHistoryPreservation || !oTopState.preserved) &&\n\t\t\t\tthis._compareCacheStates(oTopState, oNewState) !== enumState.ANCESTOR\n\t\t\t) {\n\t\t\t\t// The top state is not an ancestor of oNewState and is not preserved --> we can pop it\n\t\t\t\toLastRemovedItem = this._oManagedHistory.pop();\n\t\t\t\tiPopCount++;\n\t\t\t} else if (oTopState.preserved && removeAppStateInHash(oTopState.hash) === removeAppStateInHash(oNewState.hash)) {\n\t\t\t\t// We try to add a state that is already in cache (due to preserved flag) but with a different iapp-state\n\t\t\t\t// --> we should delete the previous entry (it will be later replaced by the new one) and stop popping\n\t\t\t\toLastRemovedItem = this._oManagedHistory.pop();\n\t\t\t\tiPopCount++;\n\t\t\t\toNewState.preserved = true;\n\t\t\t\tbreak;\n\t\t\t} else {\n\t\t\t\tbreak; // Ancestor or preserved state found --> we stop popping out states\n\t\t\t}\n\t\t}\n\n\t\t// 4. iAppState management\n\t\tthis.sIAppStateKey = this.findAppStateInHash(oNewState.hash);\n\t\tif (!this.fclEnabled && oLastRemovedItem) {\n\t\t\tconst sPreviousIAppStateKey = this.findAppStateInHash(oLastRemovedItem.hash);\n\t\t\tconst oComparisonStateResult = this._compareCacheStates(oLastRemovedItem, oNewState);\n\t\t\t// if current state doesn't contain a i-appstate and this state should replace a state containing a iAppState\n\t\t\t// then the previous iAppState is preserved\n\t\t\tif (\n\t\t\t\t!this.sIAppStateKey &&\n\t\t\t\tsPreviousIAppStateKey &&\n\t\t\t\t(oComparisonStateResult === enumState.EQUAL || oComparisonStateResult === enumState.COMPATIBLE)\n\t\t\t) {\n\t\t\t\toNewState.hash = this.setAppStateInHash(oNewState.hash, sPreviousIAppStateKey);\n\t\t\t}\n\t\t}\n\n\t\t// 5. Now we can push the state at the top of the internal history\n\t\tconst bHasSameHash = oLastRemovedItem && oNewState.hash === oLastRemovedItem.hash;\n\t\tif (this._oManagedHistory.length === 0 || this._oManagedHistory[this._oManagedHistory.length - 1].hash !== oNewState.hash) {\n\t\t\tthis._oManagedHistory.push(oNewState);\n\t\t\tif (oLastRemovedItem && removeAppStateInHash(oLastRemovedItem.hash) === removeAppStateInHash(oNewState.hash)) {\n\t\t\t\toNewState.focusControlId = oLastRemovedItem.focusControlId;\n\t\t\t\toNewState.secondaryFocusControlId = oLastRemovedItem.secondaryFocusControlId;\n\t\t\t\toNewState.focusInfo = oLastRemovedItem.focusInfo;\n\t\t\t\toNewState.secondaryFocusInfo = oLastRemovedItem.secondaryFocusInfo;\n\t\t\t}\n\t\t}\n\n\t\t// 6. Determine which actions to do on the history\n\t\tif (iPopCount === 0) {\n\t\t\t// No state was popped --> append\n\t\t\treturn { type: \"append\" };\n\t\t} else if (iPopCount === 1) {\n\t\t\t// Only 1 state was popped --> replace current hash unless hash is the same (then nothing to do)\n\t\t\treturn bHasSameHash ? { type: \"none\" } : { type: \"replace\" };\n\t\t} else {\n\t\t\t// More than 1 state was popped --> go bakc in history and replace hash if necessary\n\t\t\treturn bHasSameHash ? { type: \"back\", steps: iPopCount - 1 } : { type: \"back-replace\", steps: iPopCount - 1 };\n\t\t}\n\t}\n\n\t_blockingNavigationFilter(): \"Custom\" | \"Continue\" {\n\t\treturn this._bDisableOnHashChange ? \"Custom\" : \"Continue\";\n\t}\n\n\t/**\n\t * Disable the routing by calling the router stop method.\n\t * @final\n\t */\n\t_disableEventOnHashChange(): void {\n\t\tthis._bDisableOnHashChange = true;\n\t\tthis._oRouter.stop();\n\t}\n\n\t/**\n\t * Enable the routing by calling the router initialize method.\n\t * @param [bIgnoreCurrentHash] Ignore the last hash event triggered before the router has initialized\n\t * @final\n\t */\n\t_enableEventOnHashChange(bIgnoreCurrentHash: boolean | undefined): void {\n\t\tthis._bDisableOnHashChange = false;\n\t\tthis._oRouter.initialize(bIgnoreCurrentHash);\n\t}\n\n\t/**\n\t * Synchronizes the browser history with the internal history of the routerProxy, and triggers a navigation if needed.\n\t * @param oHistoryAction Specifies the navigation action to be performed\n\t * @param bRebuildOnly `true` if internal history is currently being rebuilt\n\t * @returns Promise (resolved when the navigation is finalized) that returns 'true' if a navigation took place, 'false' if the navigation didn't happen\n\t * @final\n\t */\n\tasync _rebuildBrowserHistory(oHistoryAction: HystoryAction, bRebuildOnly: boolean): Promise<boolean> {\n\t\t// eslint-disable-next-line @typescript-eslint/no-this-alias\n\t\tconst that = this;\n\t\treturn new Promise((resolve) => {\n\t\t\tthis.bIsRebuildHistoryRunning = true;\n\t\t\tconst oTargetState = this._oManagedHistory[this._oManagedHistory.length - 1],\n\t\t\t\tnewLevel = this._oManagedHistory.length - 1;\n\n\t\t\tfunction replaceAsync(): void {\n\t\t\t\tif (!bRebuildOnly) {\n\t\t\t\t\tthat._enableEventOnHashChange(true);\n\t\t\t\t}\n\n\t\t\t\t(that._oRouter.getHashChanger().replaceHash as Function)(oTargetState.hash);\n\t\t\t\thistory.replaceState(Object.assign({ feLevel: newLevel }, history.state), \"\");\n\n\t\t\t\tif (bRebuildOnly) {\n\t\t\t\t\tsetTimeout(function () {\n\t\t\t\t\t\t// Timeout to let 'hashchange' event be processed before by the HashChanger, so that\n\t\t\t\t\t\t// onRouteMatched notification isn't raised\n\t\t\t\t\t\tthat._enableEventOnHashChange(true);\n\t\t\t\t\t}, 0);\n\t\t\t\t}\n\n\t\t\t\tthat.bIsRebuildHistoryRunning = false;\n\t\t\t\tresolve(true); // a navigation occurred\n\t\t\t}\n\n\t\t\t// Async callbacks when navigating back, in order to let all notifications and events get processed\n\t\t\tfunction backReplaceAsync(): void {\n\t\t\t\twindow.removeEventListener(\"popstate\", backReplaceAsync);\n\t\t\t\tsetTimeout(function () {\n\t\t\t\t\t// Timeout to let 'hashchange' event be processed before by the HashChanger\n\t\t\t\t\treplaceAsync();\n\t\t\t\t}, 0);\n\t\t\t}\n\n\t\t\tfunction backAsync(): void {\n\t\t\t\twindow.removeEventListener(\"popstate\", backAsync);\n\t\t\t\tthat.bIsRebuildHistoryRunning = false;\n\t\t\t\tresolve(true); // a navigation occurred\n\t\t\t}\n\n\t\t\tthat._bIgnoreRestore = true;\n\n\t\t\tswitch (oHistoryAction.type) {\n\t\t\t\tcase \"replace\":\n\t\t\t\t\tconst focusInfo = history.state?.focusInfo;\n\t\t\t\t\t(that._oRouter.getHashChanger().replaceHash as Function)(oTargetState.hash);\n\t\t\t\t\thistory.replaceState(\n\t\t\t\t\t\tObject.assign(\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tfeLevel: newLevel,\n\t\t\t\t\t\t\t\tfocusInfo: focusInfo\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\thistory.state\n\t\t\t\t\t\t),\n\t\t\t\t\t\t\"\"\n\t\t\t\t\t);\n\t\t\t\t\tthat.bIsRebuildHistoryRunning = false;\n\t\t\t\t\tresolve(true); // a navigation occurred\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"append\":\n\t\t\t\t\tthat._oRouter.getHashChanger().setHash(oTargetState.hash);\n\t\t\t\t\thistory.replaceState(Object.assign({ feLevel: newLevel }, history.state), \"\");\n\t\t\t\t\tthat.bIsRebuildHistoryRunning = false;\n\t\t\t\t\tresolve(true); // a navigation occurred\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"back\":\n\t\t\t\t\twindow.addEventListener(\"popstate\", backAsync);\n\t\t\t\t\thistory.go(-oHistoryAction.steps);\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"back-replace\":\n\t\t\t\t\tthis._disableEventOnHashChange();\n\t\t\t\t\twindow.addEventListener(\"popstate\", backReplaceAsync);\n\t\t\t\t\thistory.go(-oHistoryAction.steps);\n\t\t\t\t\tbreak;\n\n\t\t\t\tdefault:\n\t\t\t\t\t// No navigation\n\t\t\t\t\tthis.bIsRebuildHistoryRunning = false;\n\t\t\t\t\tresolve(false); // no navigation --> resolve to false\n\t\t\t}\n\t\t});\n\t}\n\n\tgetLastHistoryEntry(): RouterState {\n\t\treturn this._oManagedHistory[this._oManagedHistory.length - 1];\n\t}\n\n\tsetPathMapping(mappings: { oldPath: string; newPath: string }[]): void {\n\t\tthis._pathMappings = mappings.filter((mapping) => {\n\t\t\treturn mapping.oldPath !== mapping.newPath;\n\t\t});\n\t}\n\n\thashGuard(): void {\n\t\tlet sHash = this.getDecodedWindowHash();\n\t\tconst currentAppName = this.getAppNameFromHash(sHash);\n\t\tif (currentAppName != this.appName) {\n\t\t\t// When doing external navigation in another window, the current window location is temporarily modified with the URL of the target app\n\t\t\t// In this case, we don't want to update the internally managed history, so we simply do nothing\n\t\t\treturn;\n\t\t}\n\n\t\tif (sHash.includes(\"restoreHistory=true\")) {\n\t\t\tthis._bApplyRestore = true;\n\t\t} else if (!this.bIsRebuildHistoryRunning && this._oRouter.isInitialized()) {\n\t\t\t// Check if the hash needs to be changed (this happens in FCL when switching b/w edit and read-only with 3 columns open)\n\t\t\tconst mapping = this._pathMappings.find((m) => {\n\t\t\t\treturn sHash.includes(m.oldPath);\n\t\t\t});\n\t\t\tif (mapping) {\n\t\t\t\t// Replace the current hash\n\t\t\t\tsHash = sHash.replace(mapping.oldPath, mapping.newPath);\n\t\t\t\thistory.replaceState(Object.assign({}, history.state), \"\", encodeURI(sHash));\n\t\t\t}\n\n\t\t\tconst aHashSplit = sHash.split(\"&/\");\n\t\t\tconst sAppHash = aHashSplit[1] ? aHashSplit[1] : \"\";\n\t\t\tif (this.checkHashWithGuard(sAppHash)) {\n\t\t\t\tconst oNewState = this._extractStateFromHash(sAppHash);\n\t\t\t\tthis._pushNewState(oNewState, false, false, this.isAppStateUpdating() ? false : true);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Compares 2 states.\n\t * @param {object} oState1\n\t * @param {object} oState2\n\t * @returns {number} The result of the comparison:\n\t *        - enumState.EQUAL if oState1 and oState2 are equal\n\t *        - enumState.COMPATIBLE if oState1 and oState2 are compatible\n\t *        - enumState.ANCESTOR if oState1 is an ancestor of oState2\n\t *        - enumState.DIFFERENT if the 2 states are different\n\t */\n\n\t_compareCacheStates(oState1: RouterState, oState2: RouterState): number {\n\t\t// First compare object keys\n\t\tif (oState1.keys.length > oState2.keys.length) {\n\t\t\treturn enumState.DIFFERENT;\n\t\t}\n\t\tlet equal = true;\n\t\tlet index;\n\n\t\tfor (index = 0; equal && index < oState1.keys.length; index++) {\n\t\t\tif (oState1.keys[index] !== oState2.keys[index]) {\n\t\t\t\tequal = false;\n\t\t\t}\n\t\t}\n\n\t\tif (!equal) {\n\t\t\t// Check routingHints\n\t\t\tif (oState1.keys.length === 1 && oState2.keys.length === 1 && this.routingHints?.[oState1.keys[0]]) {\n\t\t\t\tif (this.routingHints[oState1.keys[0]].parentOf && this.routingHints[oState1.keys[0]].parentOf.includes(oState2.keys[0])) {\n\t\t\t\t\treturn enumState.ANCESTOR;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Some objects keys are different\n\t\t\treturn enumState.DIFFERENT;\n\t\t}\n\n\t\t// All keys from oState1 are in oState2 --> check if ancestor\n\t\tif (oState1.keys.length < oState2.keys.length || oState1.screenMode < oState2.screenMode) {\n\t\t\treturn enumState.ANCESTOR;\n\t\t}\n\t\tif (oState1.screenMode > oState2.screenMode) {\n\t\t\treturn enumState.DIFFERENT; // Not sure this case can happen...\n\t\t}\n\n\t\t// At this stage, the 2 states have the same object keys (in the same order) and same screenmode\n\t\t// They can be either compatible or equal\n\t\treturn oState1.sLayout === oState2.sLayout ? enumState.EQUAL : enumState.COMPATIBLE;\n\t}\n\n\t/**\n\t * Split the app-specific route at the \"&/\" separator.\n\t *\n\t * The app-specific route consists of one or more segments separated by \"&/\".\n\t * @example\n\t * splitAppSpecificRoute(\"&/Entity('abc')/NextEntity('xyz')\");\n\t * // [\"Entity('abc')/NextEntity('xyz')\"]\n\t *\n\t * splitAppSpecificRoute(\"&/Entity('abc')/NextEntity('xyz')&/Prefix/NestedRoute\");\n\t * // [\"Entity('abc')/NextEntity('xyz')\", \"Prefix/NestedRoute\"]\n\t * @param appSpecificRoute\tThe app-specific route.\n\t * @returns An array of app-specific route segments.\n\t */\n\tprivate static splitAppSpecificRoute(appSpecificRoute: string | undefined): string[] {\n\t\tconst routeSplit = appSpecificRoute?.split(\"&/\") ?? [];\n\t\tif (!routeSplit[0]) {\n\t\t\trouteSplit.shift(); // remove the leading empty segment (the app-specific route starts with \"&/\")\n\t\t}\n\t\treturn routeSplit;\n\t}\n\n\t/**\n\t * Checks if back exits the present guard set.\n\t * @returns `true` if back exits the guard\n\t */\n\tcheckIfBackIsOutOfGuard(): boolean {\n\t\t// We use window.location.hash instead of HashChanger.getInstance().getHash() because the latter\n\t\t// replaces characters in the URL (e.g. %24 replaced by $) and it causes issues when comparing\n\t\t// with the URLs in the managed history\n\t\tconst splitHash = this.getFullHash();\n\n\t\tconst segments = RouterProxy.splitAppSpecificRoute(splitHash);\n\n\t\tif (segments.length > 1) {\n\t\t\t// there is a nested route involved -> assume we are still inside the guard\n\t\t\treturn false;\n\t\t}\n\n\t\tconst hash = segments[0] ?? \"\";\n\n\t\tlet previousHash;\n\t\tif (this._oNavigationGuard) {\n\t\t\tfor (let i = this._oManagedHistory.length - 1; i > 0; i--) {\n\t\t\t\tif (this._oManagedHistory[i].hash === hash) {\n\t\t\t\t\tpreviousHash = this._oManagedHistory[i - 1].hash;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn !previousHash || !this.checkHashWithGuard(previousHash);\n\t\t}\n\t\treturn false;\n\t}\n\n\t/**\n\t * Checks if a back navigation will exit the app.\n\t * @returns True if back exits the app\n\t */\n\tcheckIfBackExitsApp(): boolean {\n\t\tconst splitHash = this.getFullHash();\n\n\t\tconst segments = RouterProxy.splitAppSpecificRoute(splitHash);\n\n\t\tif (segments.length > 1) {\n\t\t\t// there is a nested route involved -> assume we are still inside the app\n\t\t\treturn false;\n\t\t}\n\n\t\t// If the current hash is the first one in the history, then a navback will exit the app\n\t\tconst hash = segments[0] ?? \"\";\n\t\treturn this._oManagedHistory.length > 0 && this._oManagedHistory[0].hash === hash;\n\t}\n\n\t/**\n\t * Checks if the last 2 entries in the history share the same context.\n\t * @returns `true` if they share the same context.\n\t */\n\tcheckIfBackHasSameContext(): boolean {\n\t\tif (this._oManagedHistory.length < 2) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst oCurrentState = this._oManagedHistory[this._oManagedHistory.length - 1];\n\t\tconst oPreviousState = this._oManagedHistory[this._oManagedHistory.length - 2];\n\n\t\treturn oCurrentState.hash.split(\"?\")[0] === oPreviousState.hash.split(\"?\")[0];\n\t}\n\n\t/**\n\t * Restores the focus for the current hash, if we can find it in the history.\n\t * @returns True if focus was set, false otherwise.\n\t */\n\trestoreFocusForCurrentHash(): boolean {\n\t\tconst currentHash = removeAppStateInHash(this.getHash());\n\t\tconst stateForHash = this._oManagedHistory.find((state) => {\n\t\t\treturn removeAppStateInHash(state.hash) === currentHash;\n\t\t});\n\n\t\tlet focusApplied = false;\n\t\tif (stateForHash?.focusControlId) {\n\t\t\tlet focusControl = Element.getElementById(stateForHash.focusControlId);\n\t\t\tlet focusInfo = stateForHash.focusInfo;\n\t\t\tlet useSecondary = false;\n\t\t\tif ((!focusControl || !focusControl.getFocusDomRef()) && stateForHash.secondaryFocusControlId) {\n\t\t\t\t// The control for focus is either not found or is not displayed on screen (no focusDomRef)\n\t\t\t\t// --> try the secondary control if there's one\n\t\t\t\tfocusControl = Element.getElementById(stateForHash.secondaryFocusControlId);\n\t\t\t\tfocusInfo = stateForHash.secondaryFocusInfo;\n\t\t\t\tuseSecondary = true;\n\t\t\t}\n\t\t\tif (\n\t\t\t\t// if the control is a busy table, we don't want to focus it\n\t\t\t\t// tables have their own handling to restore focus, so we don't want to interfere with that\n\t\t\t\t// unless the table was a secondary control, where we want to focus on it anyway\n\t\t\t\tfocusControl?.getParent()?.isA<Table>(\"sap.ui.mdc.Table\") &&\n\t\t\t\t(focusControl as MTable | UITable).getBusy() &&\n\t\t\t\t!useSecondary\n\t\t\t) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tfocusControl?.focus(focusInfo);\n\t\t\tfocusApplied = focusControl !== undefined;\n\t\t}\n\n\t\treturn focusApplied;\n\t}\n\n\t/**\n\t * Stores the ID of the currently focused control in the history for the current hash.\n\t *\n\t */\n\tprivate storeFocusInfoForCurrentHash(): void {\n\t\tconst currentHash = removeAppStateInHash(this.getHash());\n\t\tconst stateForHash = this._oManagedHistory.find((state) => {\n\t\t\treturn removeAppStateInHash(state.hash) === currentHash;\n\t\t});\n\t\tif (stateForHash) {\n\t\t\tconst focusControl = Element.getActiveElement();\n\t\t\tstateForHash.focusControlId = focusControl?.getId();\n\t\t\tif (focusControl) {\n\t\t\t\t// The secondary focus control is the parent table if there's one\n\t\t\t\tlet parentTable = focusControl.getParent();\n\t\t\t\twhile (parentTable && !parentTable.isA<UITable>(\"sap.ui.table.Table\") && !parentTable.isA<MTable>(\"sap.m.Table\")) {\n\t\t\t\t\tparentTable = parentTable.getParent();\n\t\t\t\t}\n\t\t\t\tstateForHash.secondaryFocusControlId = parentTable?.getId();\n\t\t\t\tstateForHash.secondaryFocusInfo = { preventScroll: true };\n\t\t\t}\n\t\t\tstateForHash.focusInfo = focusControl?.getFocusInfo();\n\t\t}\n\t}\n\n\t/**\n\t * Finds a layout value for a hash in the history.\n\t * @param hash The hash to look for in the history.\n\t * @returns A layout value if it could be found, undefined otherwise.\n\t */\n\tfindLayoutForHash(hash: string): string | undefined {\n\t\tif (!this.fclEnabled) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Remove all query parameters from the hash\n\t\tconst hashNoParam = hash.split(\"?\")[0];\n\n\t\t// Look for the state backwards, so that we find the last state in the history (e.g. if we have 2 states with the same hash but 2 different layouts)\n\t\tlet targetState: RouterState | undefined;\n\t\tfor (let index = this._oManagedHistory.length - 1; index >= 0 && targetState === undefined; index--) {\n\t\t\tif (this._oManagedHistory[index].hash.split(\"?\")[0] === hashNoParam) {\n\t\t\t\ttargetState = this._oManagedHistory[index];\n\t\t\t}\n\t\t}\n\n\t\treturn targetState?.sLayout;\n\t}\n}\n\nexport default RouterProxy;\n"],"mappings":"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","ignoreList":[]}

package/src/sap/fe/core/controllerextensions/routing/RouterProxy.ts

@@ -281,7 +281,8 @@ class RouterProxy extends BaseObject {
 	 * @param bPreserveHistory If set to true, non-ancestor entries in history will be retained
 	 * @param bDisablePreservationCache If set to true, cache preservation mechanism is disabled for the current navigation
 	 * @param bForceFocus If set to true, the logic to set the focus once the navigation is finalized will be triggered (onPageReady)
-	 * @param bPreserveShellBackNavigationHandler If not set to false, the back navigation is set to undefined
+	 * @param preserveShellBackNavigationHandler If set to true, the back navigation callback is preserved. If undefined or false, the back navigation callback is reset.
+	 * @param skipHashGuardCheck
 	 * @returns Promise (resolved when the navigation is finalized) that returns 'true' if a navigation took place, 'false' if the navigation didn't happen
 	 */
 	async navToHash(
@@ -289,23 +290,24 @@ class RouterProxy extends BaseObject {
 		bPreserveHistory?: boolean,
 		bDisablePreservationCache?: boolean,
 		bForceFocus?: boolean,
-		bPreserveShellBackNavigationHandler?: boolean
+		preserveShellBackNavigationHandler?: boolean,
+		skipHashGuardCheck?: boolean
 	): Promise<boolean> {
 		sHash = sHash.startsWith("/") ? sHash.substring(1) : sHash;
-		if (bPreserveShellBackNavigationHandler !== false) {
+		if (!preserveShellBackNavigationHandler) {
 			await this._oShellServices.setBackNavigation();
 		}
 		sHash = this.removeRestoreHistoryFlagFromHash(sHash);
 		if (this._oRouteMatchSynchronization) {
 			return this._oRouteMatchSynchronization.waitFor().then(async () => {
 				this._oRouteMatchSynchronization = undefined;
-				return this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus);
+				return this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus, skipHashGuardCheck);
 			});
 		} else {
 			if (this._bActivateRouteMatchSynchro) {
 				this.waitForRouteMatchBeforeNavigation();
 			}
-			return this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus);
+			return this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus, skipHashGuardCheck);
 		}
 	}
 
@@ -313,14 +315,15 @@ class RouterProxy extends BaseObject {
 		sHash: string,
 		bPreserveHistory?: boolean,
 		bDisablePreservationCache?: boolean,
-		bForceFocus?: boolean
+		bForceFocus?: boolean,
+		skipHashGuardCheck?: boolean
 	): Promise<boolean> {
 		// Add the app state in the hash if needed
 		if (this.fclEnabled && this.sIAppStateKey && !this.findAppStateInHash(sHash)) {
 			sHash = this.setAppStateInHash(sHash, this.sIAppStateKey);
 		}
 
-		if (!this.checkHashWithGuard(sHash)) {
+		if (!this.checkHashWithGuard(sHash) && !(skipHashGuardCheck ?? false)) {
 			if (!this.oResourceBundle) {
 				this.oResourceBundle = Library.getResourceBundleFor("sap.fe.core")!;
 			}
@@ -424,11 +427,21 @@ class RouterProxy extends BaseObject {
 	 * @param oParameters Parameters for the navigation
 	 * @param oParameters.noPreservationCache
 	 * @param oParameters.bIsStickyMode
+	 * @param oParameters.isHiddenDraftEnabled
 	 * @returns Promise that is resolved when the navigation is finalized
 	 */
-	async navTo(sRouteName: string, oParameters?: { noPreservationCache?: boolean; bIsStickyMode?: boolean }): Promise<boolean> {
+	async navTo(
+		sRouteName: string,
+		oParameters?: { noPreservationCache?: boolean; bIsStickyMode?: boolean; isHiddenDraftEnabled?: boolean }
+	): Promise<boolean> {
 		const sHash = this._oRouter.getURL(sRouteName, oParameters);
-		return this.navToHash(sHash!, false, oParameters?.noPreservationCache, false, !oParameters?.bIsStickyMode);
+		return this.navToHash(
+			sHash!,
+			false,
+			oParameters?.noPreservationCache,
+			false,
+			(oParameters?.bIsStickyMode ?? false) || (oParameters?.isHiddenDraftEnabled ?? false)
+		);
 	}
 
 	/**