@sapui5/sap.fe.core 1.101.0 → 1.103.0

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

@@ -0,0 +1,937 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/Log", "sap/fe/core/helpers/ClassSupport", "sap/fe/core/helpers/Synchronization", "sap/ui/base/Object", "sap/ui/core/Core", "sap/ui/thirdparty/URI"], function (Log, ClassSupport, Synchronization, BaseObject, Core, URI) {
+  "use strict";
+
+  var _dec, _class;
+
+  var defineUI5Class = ClassSupport.defineUI5Class;
+
+  function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  var enumState = {
+    EQUAL: 0,
+    COMPATIBLE: 1,
+    ANCESTOR: 2,
+    DIFFERENT: 3
+  };
+  var enumURLParams = {
+    LAYOUTPARAM: "layout",
+    IAPPSTATEPARAM: "sap-iapp-state"
+  };
+  /**
+   * Creates a HashGuard object.
+   *
+   * @param sGuardHash The hash used for the guard
+   * @returns The created hash guard
+   */
+
+  function createGuardFromHash(sGuardHash) {
+    return {
+      _guardHash: sGuardHash.replace(/\?[^\?]*$/, ""),
+      // Remove query part
+      check: function (sHash) {
+        return sHash.indexOf(this._guardHash) === 0;
+      }
+    };
+  }
+  /**
+   * Returns the iAppState part from a hash (or null if not found).
+   *
+   * @param sHash The hash
+   * @returns The iAppState part of the hash
+   */
+
+
+  function findAppStateInHash(sHash) {
+    var aAppState = sHash.match(new RegExp("\\?.*".concat(enumURLParams.IAPPSTATEPARAM, "=([^&]*)")));
+    return aAppState && aAppState.length > 1 ? aAppState[1] : null;
+  }
+  /**
+   * Returns a hash without its iAppState part.
+   *
+   * @param sHash The hash
+   * @returns The hash without the iAppState
+   */
+
+
+  function removeAppStateInHash(sHash) {
+    return sHash.replace(new RegExp("[&?]*".concat(enumURLParams.IAPPSTATEPARAM, "=[^&]*")), "");
+  }
+  /**
+   * Adds an iAppState inside a hash (or replaces an existing one).
+   *
+   * @param sHash The hash
+   * @param sAppStateKey The iAppState to add
+   * @returns The hash with the app state
+   */
+
+
+  function setAppStateInHash(sHash, sAppStateKey) {
+    var sNewHash;
+
+    if (sHash.indexOf(enumURLParams.IAPPSTATEPARAM) >= 0) {
+      // If there's already an iAppState parameter in the hash, replace it
+      sNewHash = sHash.replace(new RegExp("".concat(enumURLParams.IAPPSTATEPARAM, "=[^&]*")), "".concat(enumURLParams.IAPPSTATEPARAM, "=").concat(sAppStateKey));
+    } else {
+      // Add the iAppState parameter in the hash
+      if (sHash.indexOf("?") < 0) {
+        sNewHash = "".concat(sHash, "?");
+      } else {
+        sNewHash = "".concat(sHash, "&");
+      }
+
+      sNewHash += "".concat(enumURLParams.IAPPSTATEPARAM, "=").concat(sAppStateKey);
+    }
+
+    return sNewHash;
+  }
+
+  var RouterProxy = (_dec = defineUI5Class("sap.fe.core.RouterProxy"), _dec(_class = /*#__PURE__*/function (_BaseObject) {
+    _inheritsLoose(RouterProxy, _BaseObject);
+
+    function RouterProxy() {
+      var _this;
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _BaseObject.call.apply(_BaseObject, [this].concat(args)) || this;
+      _this.bIsRebuildHistoryRunning = false;
+      _this.bIsComputingTitleHierachy = false;
+      _this.bIsGuardCrossAllowed = false;
+      _this.sIAppStateKey = null;
+      _this._bActivateRouteMatchSynchro = false;
+      _this._bApplyRestore = false;
+      _this._bDelayedRebuild = false;
+      _this._pathMappings = [];
+      return _this;
+    }
+
+    var _proto = RouterProxy.prototype;
+
+    _proto.init = function init(oAppComponent, isfclEnabled) {
+      var _this2 = this;
+
+      // Save the name of the app (including startup parameters) for rebuilding full hashes later
+      oAppComponent.getService("shellServices").then(function () {
+        _this2._oShellServices = oAppComponent.getShellServices();
+
+        _this2.initRaw(oAppComponent.getRouter()); // We want to wait until the initial routeMatched is done before doing any navigation
+
+
+        _this2.waitForRouteMatchBeforeNavigation(); // Set feLevel=0 for the first Application page in the history
+
+
+        history.replaceState(Object.assign({
+          feLevel: 0
+        }, history.state), "", window.location);
+        _this2.fclEnabled = isfclEnabled;
+        _this2._fnBlockingNavFilter = _this2._blockingNavigationFilter.bind(_this2);
+
+        _this2._oShellServices.registerNavigationFilter(_this2._fnBlockingNavFilter);
+      }).catch(function (oError) {
+        Log.error("Cannot retrieve the shell services", oError);
+      });
+      this._fnHashGuard = this.hashGuard.bind(this);
+      window.addEventListener("popstate", this._fnHashGuard);
+      this._bDisableOnHashChange = false;
+      this._bIgnoreRestore = false;
+      this._bForceFocus = true; // Trigger the focus mechanism for the first view displayed by the app
+    };
+
+    _proto.destroy = function destroy() {
+      if (this._oShellServices) {
+        this._oShellServices.unregisterNavigationFilter(this._fnBlockingNavFilter);
+      }
+
+      window.removeEventListener("popstate", this._fnHashGuard);
+    }
+    /**
+     * Raw initialization (for unit tests).
+     *
+     * @param oRouter The router used by this proxy
+     */
+    ;
+
+    _proto.initRaw = function initRaw(oRouter) {
+      this._oRouter = oRouter;
+      this._oManagedHistory = [];
+      this._oNavigationGuard = null;
+      var sCurrentAppHash = this.getHash();
+
+      this._oManagedHistory.push(this._extractStateFromHash(sCurrentAppHash)); // Set the iAppState if the initial hash contains one
+
+
+      this.sIAppStateKey = findAppStateInHash(sCurrentAppHash);
+    };
+
+    _proto.getHash = function getHash() {
+      return this._oRouter.getHashChanger().getHash();
+    };
+
+    _proto.isFocusForced = function isFocusForced() {
+      return this._bForceFocus;
+    };
+
+    _proto.setFocusForced = function setFocusForced(bForced) {
+      this._bForceFocus = bForced;
+    }
+    /**
+     * Resets the internal variable sIAppStateKey.
+     *
+     * @function
+     * @name sap.fe.core.RouterProxy#removeIAppStateKey
+     * @ui5-restricted
+     */
+    ;
+
+    _proto.removeIAppStateKey = function removeIAppStateKey() {
+      this.sIAppStateKey = null;
+    }
+    /**
+     * Navigates to a specific hash.
+     *
+     * @function
+     * @name sap.fe.core.RouterProxy#navToHash
+     * @memberof sap.fe.core.RouterProxy
+     * @static
+     * @param sHash Hash to be navigated to
+     * @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
+     * @returns Promise (resolved when the navigation is finalized) that returns 'true' if a navigation took place, 'false' if the navigation didn't happen
+     * @ui5-restricted
+     */
+    ;
+
+    _proto.navToHash = function navToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus, bPreserveShellBackNavigationHandler) {
+      var _this3 = this;
+
+      if (bPreserveShellBackNavigationHandler !== false) {
+        this._oShellServices.setBackNavigation();
+      }
+
+      if (this._oRouteMatchSynchronization) {
+        return this._oRouteMatchSynchronization.waitFor().then(function () {
+          _this3._oRouteMatchSynchronization = undefined;
+          return _this3._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus);
+        });
+      } else {
+        if (this._bActivateRouteMatchSynchro) {
+          this.waitForRouteMatchBeforeNavigation();
+        }
+
+        return this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus);
+      }
+    };
+
+    _proto._internalNavToHash = function _internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus) {
+      // Add the app state in the hash if needed
+      if (this.fclEnabled && this.sIAppStateKey && !findAppStateInHash(sHash)) {
+        sHash = setAppStateInHash(sHash, this.sIAppStateKey);
+      }
+
+      if (!this.checkHashWithGuard(sHash)) {
+        if (!this.oResourceBundle) {
+          this.oResourceBundle = Core.getLibraryResourceBundle("sap.fe.core");
+        } // We have to use a confirm here for UI consistency reasons, as with some scenarios
+        // in the EditFlow we rely on a UI5 mechanism that displays a confirm dialog.
+        // eslint-disable-next-line no-alert
+
+
+        if (!confirm(this.oResourceBundle.getText("C_ROUTER_PROXY_SAPFE_EXIT_NOTSAVED_MESSAGE"))) {
+          // The user clicked on Cancel --> cancel navigation
+          return Promise.resolve(false);
+        }
+
+        this.bIsGuardCrossAllowed = true;
+      } // In case the navigation will cause a new view to be displayed, we force the focus
+      // I.e. if the keys for the hash we're navigating to is a superset of the current hash keys.
+
+
+      var oNewState = this._extractStateFromHash(sHash);
+
+      if (!this._bForceFocus) {
+        // If the focus was already forced, keep it
+        var aCurrentHashKeys = this._extractKeysFromHash(this.getHash());
+
+        this._bForceFocus = bForceFocus || aCurrentHashKeys.length < oNewState.keys.length && aCurrentHashKeys.every(function (key, index) {
+          return key === oNewState.keys[index];
+        });
+      }
+
+      var oHistoryAction = this._pushNewState(oNewState, false, bPreserveHistory, bDisablePreservationCache);
+
+      return this._rebuildBrowserHistory(oHistoryAction, false);
+    }
+    /**
+     * Clears browser history if entries have been added without using the RouterProxy.
+     * Updates the internal history accordingly.
+     *
+     * @returns Promise that is resolved once the history is rebuilt
+     */
+    ;
+
+    _proto.restoreHistory = function restoreHistory() {
+      if (this._bApplyRestore) {
+        this._bApplyRestore = false;
+        var sTargetHash = this.getHash();
+        sTargetHash = sTargetHash.replace(/(\?|&)restoreHistory=true/, "");
+
+        var oNewState = this._extractStateFromHash(sTargetHash);
+
+        var oHistoryAction = this._pushNewState(oNewState, true, false, true);
+
+        return this._rebuildBrowserHistory(oHistoryAction, true);
+      } else {
+        return Promise.resolve();
+      }
+    }
+    /**
+     * Navigates back in the history.
+     *
+     * @returns Promise that is resolved when the navigation is finalized
+     */
+    ;
+
+    _proto.navBack = function navBack() {
+      var sCurrentHash = this.getHash();
+      var sPreviousHash; // Look for the current hash in the managed history
+
+      for (var i = this._oManagedHistory.length - 1; i > 0; i--) {
+        if (this._oManagedHistory[i].hash === sCurrentHash) {
+          sPreviousHash = this._oManagedHistory[i - 1].hash;
+          break;
+        }
+      }
+
+      if (sPreviousHash) {
+        return this.navToHash(sPreviousHash);
+      } else {
+        // We couldn't find a previous hash in history
+        // This can happen when navigating from a transient hash in a create app, and
+        // in that case history.back would go back to the FLP
+        window.history.back();
+        return Promise.resolve();
+      }
+    }
+    /**
+     * Navigates to a route with parameters.
+     *
+     * @param sRouteName The route name to be navigated to
+     * @param oParameters Parameters for the navigation
+     * @returns Promise that is resolved when the navigation is finalized
+     * @ui5-restricted
+     */
+    ;
+
+    _proto.navTo = function navTo(sRouteName, oParameters) {
+      var sHash = this._oRouter.getURL(sRouteName, oParameters);
+
+      return this.navToHash(sHash, false, oParameters.noPreservationCache, false, !oParameters.bIsStickyMode);
+    }
+    /**
+     * Exits the current app by navigating back
+     * to the previous app (if any) or the FLP.
+     *
+     * @returns Promise that is resolved when we exit the app
+     */
+    ;
+
+    _proto.exitFromApp = function exitFromApp() {
+      return this._oShellServices.backToPreviousApp();
+    }
+    /**
+     * Checks whether a given hash can have an impact on the current state
+     * i.e. if the hash is equal, compatible or an ancestor of the current state.
+     *
+     * @param sHash `true` if there is an impact
+     * @returns If there is an impact
+     */
+    ;
+
+    _proto.isCurrentStateImpactedBy = function isCurrentStateImpactedBy(sHash) {
+      if (sHash[0] === "/") {
+        sHash = sHash.substring(1);
+      }
+
+      var oLocalGuard = createGuardFromHash(sHash);
+      return oLocalGuard.check(this.getHash());
+    }
+    /**
+     * Checks if a navigation is currently being processed.
+     *
+     * @returns `false` if a navigation has been triggered in the RouterProxy and is not yet finalized
+     */
+    ;
+
+    _proto.isNavigationFinalized = function isNavigationFinalized() {
+      return !this.bIsRebuildHistoryRunning && !this._bDelayedRebuild;
+    }
+    /**
+     * Sets the last state as a guard.
+     * Each future navigation will be checked against this guard, and a confirmation dialog will
+     * be displayed before the navigation crosses the guard (i.e. goes to an ancestor of the guard).
+     *
+     * @param sHash The hash for the guard
+     */
+    ;
+
+    _proto.setNavigationGuard = function setNavigationGuard(sHash) {
+      this._oNavigationGuard = createGuardFromHash(sHash);
+      this.bIsGuardCrossAllowed = false;
+    }
+    /**
+     * Disables the navigation guard.
+     */
+    ;
+
+    _proto.discardNavigationGuard = function discardNavigationGuard() {
+      this._oNavigationGuard = null;
+    }
+    /**
+     * Checks for the availability of the navigation guard.
+     *
+     * @returns `true` if navigating guard is available
+     */
+    ;
+
+    _proto.hasNavigationGuard = function hasNavigationGuard() {
+      return this._oNavigationGuard !== null;
+    }
+    /**
+     * Tests a hash against the navigation guard.
+     *
+     * @param sHash The hash to be tested
+     * @returns `true` if navigating to the hash doesn't cross the guard
+     */
+    ;
+
+    _proto.checkHashWithGuard = function checkHashWithGuard(sHash) {
+      return this._oNavigationGuard === null || this._oNavigationGuard.check(sHash);
+    }
+    /**
+     * Checks if the user allowed the navigation guard to be crossed.
+     *
+     * @returns `true` if crossing the guard has been allowed by the user
+     */
+    ;
+
+    _proto.isGuardCrossAllowedByUser = function isGuardCrossAllowedByUser() {
+      return this.bIsGuardCrossAllowed;
+    }
+    /**
+     * Activates the synchronization for routeMatchedEvent.
+     * The next NavToHash call will create a Synchronization object that will be resolved
+     * by the corresponding onRouteMatched event, preventing another NavToHash to happen in parallel.
+     */
+    ;
+
+    _proto.activateRouteMatchSynchronization = function activateRouteMatchSynchronization() {
+      this._bActivateRouteMatchSynchro = true;
+    }
+    /**
+     * Resolve the routeMatch synchronization object, unlocking potential pending NavToHash calls.
+     */
+    ;
+
+    _proto.resolveRouteMatch = function resolveRouteMatch() {
+      if (this._oRouteMatchSynchronization) {
+        this._oRouteMatchSynchronization.resolve();
+      }
+    }
+    /**
+     * Makes sure no navigation can happen before a routeMatch happened.
+     */
+    ;
+
+    _proto.waitForRouteMatchBeforeNavigation = function waitForRouteMatchBeforeNavigation() {
+      this._oRouteMatchSynchronization = new Synchronization();
+      this._bActivateRouteMatchSynchro = false;
+    };
+
+    _proto._extractKeysFromHash = function _extractKeysFromHash(sHash) {
+      if (sHash === undefined) {
+        sHash = "";
+      }
+
+      var sHashNoParams = sHash.split("?")[0]; // remove params
+
+      var aTokens = sHashNoParams.split("/");
+      var aKeys = [];
+      aTokens.forEach(function (sToken) {
+        var regexKey = /[^\(\)]+\([^\(\)]+\)/; // abc(def)
+
+        if (regexKey.test(sToken)) {
+          aKeys.push(sToken.split("(")[0]);
+        }
+      });
+      return aKeys;
+    }
+    /**
+     * Builds a state from a hash.
+     *
+     * @param sHash The hash to be used as entry
+     * @returns The state
+     * @ui5-restricted
+     */
+    ;
+
+    _proto._extractStateFromHash = function _extractStateFromHash(sHash) {
+      if (sHash === undefined) {
+        sHash = "";
+      }
+
+      var oState = {
+        keys: this._extractKeysFromHash(sHash)
+      }; // Retrieve layout (if any)
+
+      var aLayout = sHash.match(new RegExp("\\?.*".concat(enumURLParams.LAYOUTPARAM, "=([^&]*)")));
+      oState.sLayout = aLayout && aLayout.length > 1 ? aLayout[1] : null;
+
+      if (oState.sLayout === "MidColumnFullScreen") {
+        oState.screenMode = 1;
+      } else if (oState.sLayout === "EndColumnFullScreen") {
+        oState.screenMode = 2;
+      } else {
+        oState.screenMode = 0;
+      }
+
+      oState.hash = sHash;
+      return oState;
+    }
+    /**
+     * Adds a new state into the internal history structure.
+     * Makes sure this new state is added after an ancestor.
+     * Also sets the iAppState key in the whole history.
+     *
+     * @memberof sap.fe.core.RouterProxy
+     * @param oNewState The new state to be added
+     * @param bRebuildOnly `true` if we're rebuilding the history after a shell menu navigation
+     * @param bPreserveHistory If set to true, non-ancestor entries in history will be retained
+     * @param bDisableHistoryPreservation Disable the mechanism to retained marked entries in cache
+     * @returns The new state
+     * @ui5-restricted
+     * @final
+     */
+    ;
+
+    _proto._pushNewState = function _pushNewState(oNewState, bRebuildOnly, bPreserveHistory, bDisableHistoryPreservation) {
+      var _this4 = this;
+
+      var sCurrentHash = this.getHash();
+      var lastIndex = this._oManagedHistory.length - 1;
+      var iPopCount = bRebuildOnly ? 1 : 0; // 1. Do some cleanup in the managed history : in case the user has navigated back in the browser history, we need to remove
+      // the states ahead in history and make sure the top state corresponds to the current page
+      // We don't do that when restoring the history, as the current state has been added on top of the browser history
+      // and is not reflected in the managed history
+
+      if (!bRebuildOnly) {
+        while (lastIndex >= 0 && this._oManagedHistory[lastIndex].hash !== sCurrentHash) {
+          this._oManagedHistory.pop();
+
+          lastIndex--;
+        }
+
+        if (this._oManagedHistory.length === 0) {
+          // We couldn't find the current location in the history. This can happen if a browser reload
+          // happened, causing a reinitialization of the managed history.
+          // In that case, we use the current location as the new starting point in the managed history
+          this._oManagedHistory.push(this._extractStateFromHash(sCurrentHash));
+
+          history.replaceState(Object.assign({
+            feLevel: 0
+          }, history.state), "");
+        }
+      } // 2. Mark the top state as preserved if required
+
+
+      if (bPreserveHistory && !bDisableHistoryPreservation) {
+        this._oManagedHistory[this._oManagedHistory.length - 1].preserved = true;
+      } // 3. Then pop all states until we find an ancestor of the new state, or we find a state that need to be preserved
+
+
+      var oLastRemovedItem;
+
+      while (this._oManagedHistory.length > 0) {
+        var oTopState = this._oManagedHistory[this._oManagedHistory.length - 1];
+
+        if ((bDisableHistoryPreservation || !oTopState.preserved) && this._compareCacheStates(oTopState, oNewState) !== enumState.ANCESTOR) {
+          // The top state is not an ancestor of oNewState and is not preserved --> we can pop it
+          oLastRemovedItem = this._oManagedHistory.pop();
+          iPopCount++;
+        } else if (oTopState.preserved && removeAppStateInHash(oTopState.hash) === removeAppStateInHash(oNewState.hash)) {
+          // We try to add a state that is already in cache (due to preserved flag) but with a different iapp-state
+          // --> we should delete the previous entry (it will be later replaced by the new one) and stop popping
+          oLastRemovedItem = this._oManagedHistory.pop();
+          iPopCount++;
+          oNewState.preserved = true;
+          break;
+        } else {
+          break; // Ancestor or preserved state found --> we stop popping out states
+        }
+      } // 4. iAppState management
+
+
+      this.sIAppStateKey = findAppStateInHash(oNewState.hash);
+
+      if (this.fclEnabled && this.sIAppStateKey) {
+        // In case of FCL, the new app state needs to be applied to the whole history
+        this._oManagedHistory.forEach(function (oManagedState) {
+          oManagedState.hash = setAppStateInHash(oManagedState.hash, _this4.sIAppStateKey);
+        });
+      } else if (!this.fclEnabled && oLastRemovedItem) {
+        var sPreviousIAppStateKey = findAppStateInHash(oLastRemovedItem.hash);
+
+        var oComparisonStateResult = this._compareCacheStates(oLastRemovedItem, oNewState); // if current state doesn't contain a i-appstate and this state should replace a state containing a iAppState
+        // then the previous iAppState is preserved
+
+
+        if (!this.sIAppStateKey && sPreviousIAppStateKey && (oComparisonStateResult === enumState.EQUAL || oComparisonStateResult === enumState.COMPATIBLE)) {
+          oNewState.hash = setAppStateInHash(oNewState.hash, sPreviousIAppStateKey);
+        }
+      } // 5. Now we can push the state at the top of the internal history
+
+
+      var bHasSameHash = oLastRemovedItem && oNewState.hash === oLastRemovedItem.hash;
+
+      if (this._oManagedHistory.length === 0 || this._oManagedHistory[this._oManagedHistory.length - 1].hash !== oNewState.hash) {
+        this._oManagedHistory.push(oNewState);
+      } // 6. Determine which actions to do on the history
+
+
+      if (iPopCount === 0) {
+        // No state was popped --> append
+        return {
+          type: "append"
+        };
+      } else if (iPopCount === 1) {
+        // Only 1 state was popped --> replace current hash unless hash is the same (then nothing to do)
+        return bHasSameHash ? {
+          type: "none"
+        } : {
+          type: "replace"
+        };
+      } else {
+        // More than 1 state was popped --> go bakc in history and replace hash if necessary
+        return bHasSameHash ? {
+          type: "back",
+          steps: iPopCount - 1
+        } : {
+          type: "back-replace",
+          steps: iPopCount - 1
+        };
+      }
+    };
+
+    _proto._blockingNavigationFilter = function _blockingNavigationFilter() {
+      return this._bDisableOnHashChange ? "Custom" : "Continue";
+    }
+    /**
+     * Disable the routing by calling the router stop method.
+     *
+     * @function
+     * @memberof sap.fe.core.RouterProxy
+     * @ui5-restricted
+     * @final
+     */
+    ;
+
+    _proto._disableEventOnHashChange = function _disableEventOnHashChange() {
+      this._bDisableOnHashChange = true;
+
+      this._oRouter.stop();
+    }
+    /**
+     * Enable the routing by calling the router initialize method.
+     *
+     * @function
+     * @name sap.fe.core.RouterProxy#_enableEventOnHashChange
+     * @memberof sap.fe.core.RouterProxy
+     * @param [bIgnoreCurrentHash] Ignore the last hash event triggered before the router has initialized
+     * @ui5-restricted
+     * @final
+     */
+    ;
+
+    _proto._enableEventOnHashChange = function _enableEventOnHashChange(bIgnoreCurrentHash) {
+      this._bDisableOnHashChange = false;
+
+      this._oRouter.initialize(bIgnoreCurrentHash);
+    }
+    /**
+     * Synchronizes the browser history with the internal history of the routerProxy, and triggers a navigation if needed.
+     *
+     * @memberof sap.fe.core.RouterProxy
+     * @param oHistoryAction Specifies the navigation action to be performed
+     * @param bRebuildOnly `true` if internal history is currently being rebuilt
+     * @returns Promise (resolved when the navigation is finalized) that returns 'true' if a navigation took place, 'false' if the navigation didn't happen
+     * @ui5-restricted
+     * @final
+     */
+    ;
+
+    _proto._rebuildBrowserHistory = function _rebuildBrowserHistory(oHistoryAction, bRebuildOnly) {
+      var _this5 = this;
+
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      var that = this;
+      return new Promise(function (resolve) {
+        _this5.bIsRebuildHistoryRunning = true;
+        var oTargetState = _this5._oManagedHistory[_this5._oManagedHistory.length - 1],
+            newLevel = _this5._oManagedHistory.length - 1;
+
+        function replaceAsync() {
+          if (!bRebuildOnly) {
+            that._enableEventOnHashChange(true);
+          }
+
+          that._oRouter.getHashChanger().replaceHash(oTargetState.hash);
+
+          history.replaceState(Object.assign({
+            feLevel: newLevel
+          }, history.state), "");
+
+          if (bRebuildOnly) {
+            setTimeout(function () {
+              // Timeout to let 'hashchange' event be processed before by the HashChanger, so that
+              // onRouteMatched notification isn't raised
+              that._enableEventOnHashChange(true);
+            }, 0);
+          }
+
+          that.bIsRebuildHistoryRunning = false;
+          resolve(true); // a navigation occurred
+        } // Async callbacks when navigating back, in order to let all notifications and events get processed
+
+
+        function backReplaceAsync() {
+          window.removeEventListener("popstate", backReplaceAsync);
+          setTimeout(function () {
+            // Timeout to let 'hashchange' event be processed before by the HashChanger
+            replaceAsync();
+          }, 0);
+        }
+
+        function backAsync() {
+          window.removeEventListener("popstate", backAsync);
+          that.bIsRebuildHistoryRunning = false;
+          resolve(true); // a navigation occurred
+        }
+
+        that._bIgnoreRestore = true;
+
+        switch (oHistoryAction.type) {
+          case "replace":
+            that._oRouter.getHashChanger().replaceHash(oTargetState.hash);
+
+            history.replaceState(Object.assign({
+              feLevel: newLevel
+            }, history.state), "");
+            that.bIsRebuildHistoryRunning = false;
+            resolve(true); // a navigation occurred
+
+            break;
+
+          case "append":
+            that._oRouter.getHashChanger().setHash(oTargetState.hash);
+
+            history.replaceState(Object.assign({
+              feLevel: newLevel
+            }, history.state), "");
+            that.bIsRebuildHistoryRunning = false;
+            resolve(true); // a navigation occurred
+
+            break;
+
+          case "back":
+            window.addEventListener("popstate", backAsync);
+            history.go(-oHistoryAction.steps);
+            break;
+
+          case "back-replace":
+            _this5._disableEventOnHashChange();
+
+            window.addEventListener("popstate", backReplaceAsync);
+            history.go(-oHistoryAction.steps);
+            break;
+
+          default:
+            // No navigation
+            _this5.bIsRebuildHistoryRunning = false;
+            resolve(false);
+          // no navigation --> resolve to false
+        }
+      });
+    };
+
+    _proto.getLastHistoryEntry = function getLastHistoryEntry() {
+      return this._oManagedHistory[this._oManagedHistory.length - 1];
+    };
+
+    _proto.setPathMapping = function setPathMapping(mappings) {
+      this._pathMappings = mappings.filter(function (mapping) {
+        return mapping.oldPath !== mapping.newPath;
+      });
+    };
+
+    _proto.hashGuard = function hashGuard() {
+      var _this6 = this;
+
+      var sHash = window.location.hash;
+
+      if (sHash.indexOf("restoreHistory=true") !== -1) {
+        this._bApplyRestore = true;
+      } else if (!this.bIsRebuildHistoryRunning) {
+        // Check if the hash needs to be changed (this happens in FCL when switching b/w edit and read-only with 3 columns open)
+        var mapping = this._pathMappings.find(function (m) {
+          return sHash.indexOf(m.oldPath) >= 0;
+        });
+
+        if (mapping) {
+          // Replace the current hash
+          sHash = sHash.replace(mapping.oldPath, mapping.newPath);
+          history.replaceState(Object.assign({}, history.state), "", sHash);
+        } else {
+          var aHashSplit = sHash.split("&/");
+          var sAppHash = aHashSplit[1] ? aHashSplit[1] : "";
+
+          if (this.checkHashWithGuard(sAppHash)) {
+            this._bDelayedRebuild = true;
+
+            var oNewState = this._extractStateFromHash(sAppHash);
+
+            this._pushNewState(oNewState, false, false, true);
+
+            setTimeout(function () {
+              _this6._bDelayedRebuild = false;
+            }, 0);
+          }
+        }
+      }
+    }
+    /**
+     * Compares 2 states.
+     *
+     * @param {object} oState1
+     * @param {object} oState2
+     * @returns {number} The result of the comparison:
+     *        - enumState.EQUAL if oState1 and oState2 are equal
+     *        - enumState.COMPATIBLE if oState1 and oState2 are compatible
+     *        - enumState.ANCESTOR if oState1 is an ancestor of oState2
+     *        - enumState.DIFFERENT if the 2 states are different
+     */
+    ;
+
+    _proto._compareCacheStates = function _compareCacheStates(oState1, oState2) {
+      // First compare object keys
+      if (oState1.keys.length > oState2.keys.length) {
+        return enumState.DIFFERENT;
+      }
+
+      var equal = true;
+      var index;
+
+      for (index = 0; equal && index < oState1.keys.length; index++) {
+        if (oState1.keys[index] !== oState2.keys[index]) {
+          equal = false;
+        }
+      }
+
+      if (!equal) {
+        // Some objects keys are different
+        return enumState.DIFFERENT;
+      } // All keys from oState1 are in oState2 --> check if ancestor
+
+
+      if (oState1.keys.length < oState2.keys.length || oState1.screenMode < oState2.screenMode) {
+        return enumState.ANCESTOR;
+      }
+
+      if (oState1.screenMode > oState2.screenMode) {
+        return enumState.DIFFERENT; // Not sure this case can happen...
+      } // At this stage, the 2 states have the same object keys (in the same order) and same screenmode
+      // They can be either compatible or equal
+
+
+      return oState1.sLayout === oState2.sLayout ? enumState.EQUAL : enumState.COMPATIBLE;
+    }
+    /**
+     * Checks if back exits the present guard set.
+     *
+     * @param sPresentHash The current hash. Only used for unit tests.
+     * @returns `true` if back exits there is a guard exit on back
+     */
+    ;
+
+    _proto.checkIfBackIsOutOfGuard = function checkIfBackIsOutOfGuard(sPresentHash) {
+      var sPrevHash;
+      var sCurrentHash;
+
+      if (sPresentHash === undefined) {
+        // We use window.location.hash instead of HashChanger.getInstance().getHash() because the latter
+        // replaces characters in the URL (e.g. %24 replaced by $) and it causes issues when comparing
+        // with the URLs in the managed history
+        var oSplitHash = this._oShellServices.splitHash(window.location.hash);
+
+        if (oSplitHash && oSplitHash.appSpecificRoute) {
+          sCurrentHash = oSplitHash.appSpecificRoute;
+
+          if (sCurrentHash.indexOf("&/") === 0) {
+            sCurrentHash = sCurrentHash.substring(2);
+          }
+        } else {
+          sCurrentHash = window.location.hash.substring(1); // To remove the '#'
+
+          if (sCurrentHash[0] === "/") {
+            sCurrentHash = sCurrentHash.substring(1);
+          }
+        }
+      } else {
+        sCurrentHash = sPresentHash;
+      }
+
+      sPresentHash = URI.decode(sCurrentHash);
+
+      if (this._oNavigationGuard) {
+        for (var i = this._oManagedHistory.length - 1; i > 0; i--) {
+          if (this._oManagedHistory[i].hash === sPresentHash) {
+            sPrevHash = this._oManagedHistory[i - 1].hash;
+            break;
+          }
+        }
+
+        return !sPrevHash || !this.checkHashWithGuard(sPrevHash);
+      }
+
+      return false;
+    }
+    /**
+     * Checks if the last 2 entries in the history share the same context.
+     *
+     * @returns `true` if they share the same context.
+     */
+    ;
+
+    _proto.checkIfBackHasSameContext = function checkIfBackHasSameContext() {
+      if (this._oManagedHistory.length < 2) {
+        return false;
+      }
+
+      var oCurrentState = this._oManagedHistory[this._oManagedHistory.length - 1];
+      var oPreviousState = this._oManagedHistory[this._oManagedHistory.length - 2];
+      return oCurrentState.hash.split("?")[0] === oPreviousState.hash.split("?")[0];
+    };
+
+    return RouterProxy;
+  }(BaseObject)) || _class);
+  return RouterProxy;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["RouterProxy.ts"],"names":["enumState","EQUAL","COMPATIBLE","ANCESTOR","DIFFERENT","enumURLParams","LAYOUTPARAM","IAPPSTATEPARAM","createGuardFromHash","sGuardHash","_guardHash","replace","check","sHash","indexOf","findAppStateInHash","aAppState","match","RegExp","length","removeAppStateInHash","setAppStateInHash","sAppStateKey","sNewHash","RouterProxy","defineUI5Class","bIsRebuildHistoryRunning","bIsComputingTitleHierachy","bIsGuardCrossAllowed","sIAppStateKey","_bActivateRouteMatchSynchro","_bApplyRestore","_bDelayedRebuild","_pathMappings","init","oAppComponent","isfclEnabled","getService","then","_oShellServices","getShellServices","initRaw","getRouter","waitForRouteMatchBeforeNavigation","history","replaceState","Object","assign","feLevel","state","window","location","fclEnabled","_fnBlockingNavFilter","_blockingNavigationFilter","bind","registerNavigationFilter","catch","oError","Log","error","_fnHashGuard","hashGuard","addEventListener","_bDisableOnHashChange","_bIgnoreRestore","_bForceFocus","destroy","unregisterNavigationFilter","removeEventListener","oRouter","_oRouter","_oManagedHistory","_oNavigationGuard","sCurrentAppHash","getHash","push","_extractStateFromHash","getHashChanger","isFocusForced","setFocusForced","bForced","removeIAppStateKey","navToHash","bPreserveHistory","bDisablePreservationCache","bForceFocus","bPreserveShellBackNavigationHandler","setBackNavigation","_oRouteMatchSynchronization","waitFor","undefined","_internalNavToHash","checkHashWithGuard","oResourceBundle","Core","getLibraryResourceBundle","confirm","getText","Promise","resolve","oNewState","aCurrentHashKeys","_extractKeysFromHash","keys","every","key","index","oHistoryAction","_pushNewState","_rebuildBrowserHistory","restoreHistory","sTargetHash","navBack","sCurrentHash","sPreviousHash","i","hash","back","navTo","sRouteName","oParameters","getURL","noPreservationCache","bIsStickyMode","exitFromApp","backToPreviousApp","isCurrentStateImpactedBy","substring","oLocalGuard","isNavigationFinalized","setNavigationGuard","discardNavigationGuard","hasNavigationGuard","isGuardCrossAllowedByUser","activateRouteMatchSynchronization","resolveRouteMatch","Synchronization","sHashNoParams","split","aTokens","aKeys","forEach","sToken","regexKey","test","oState","aLayout","sLayout","screenMode","bRebuildOnly","bDisableHistoryPreservation","lastIndex","iPopCount","pop","preserved","oLastRemovedItem","oTopState","_compareCacheStates","oManagedState","sPreviousIAppStateKey","oComparisonStateResult","bHasSameHash","type","steps","_disableEventOnHashChange","stop","_enableEventOnHashChange","bIgnoreCurrentHash","initialize","that","oTargetState","newLevel","replaceAsync","replaceHash","setTimeout","backReplaceAsync","backAsync","setHash","go","getLastHistoryEntry","setPathMapping","mappings","filter","mapping","oldPath","newPath","find","m","aHashSplit","sAppHash","oState1","oState2","equal","checkIfBackIsOutOfGuard","sPresentHash","sPrevHash","oSplitHash","splitHash","appSpecificRoute","URI","decode","checkIfBackHasSameContext","oCurrentState","oPreviousState","BaseObject"],"mappings":"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","sourceRoot":".","sourcesContent":["import type ResourceBundle from \"sap/base/i18n/ResourceBundle\";\nimport Log from \"sap/base/Log\";\nimport { defineUI5Class } from \"sap/fe/core/helpers/ClassSupport\";\nimport Synchronization from \"sap/fe/core/helpers/Synchronization\";\nimport type { IShellServices } from \"sap/fe/core/services/ShellServicesFactory\";\nimport BaseObject from \"sap/ui/base/Object\";\nimport Core from \"sap/ui/core/Core\";\nimport type Router from \"sap/ui/core/routing/Router\";\nimport URI from \"sap/ui/thirdparty/URI\";\nimport type { CoreEx } from \"types/extension_types\";\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\n/**\n * Creates a HashGuard object.\n *\n * @param sGuardHash The hash used for the guard\n * @returns The created hash guard\n */\nfunction createGuardFromHash(sGuardHash: string) {\n\treturn {\n\t\t_guardHash: sGuardHash.replace(/\\?[^\\?]*$/, \"\"), // Remove query part\n\t\tcheck: function (sHash: any) {\n\t\t\treturn sHash.indexOf(this._guardHash) === 0;\n\t\t}\n\t};\n}\n/**\n * Returns the iAppState part from a hash (or null if not found).\n *\n * @param sHash The hash\n * @returns The iAppState part of the hash\n */\nfunction findAppStateInHash(sHash: string): string | null {\n\tconst aAppState = sHash.match(new RegExp(`\\\\?.*${enumURLParams.IAPPSTATEPARAM}=([^&]*)`));\n\treturn aAppState && aAppState.length > 1 ? aAppState[1] : null;\n}\n/**\n * Returns a hash without its iAppState part.\n *\n * @param sHash The hash\n * @returns The hash without the iAppState\n */\nfunction removeAppStateInHash(sHash: string) {\n\treturn sHash.replace(new RegExp(`[&?]*${enumURLParams.IAPPSTATEPARAM}=[^&]*`), \"\");\n}\n/**\n * Adds an iAppState inside a hash (or replaces an existing one).\n *\n * @param sHash The hash\n * @param sAppStateKey The iAppState to add\n * @returns The hash with the app state\n */\nfunction setAppStateInHash(sHash: any, sAppStateKey: any) {\n\tlet sNewHash;\n\n\tif (sHash.indexOf(enumURLParams.IAPPSTATEPARAM) >= 0) {\n\t\t// If there's already an iAppState parameter in the hash, replace it\n\t\tsNewHash = sHash.replace(new RegExp(`${enumURLParams.IAPPSTATEPARAM}=[^&]*`), `${enumURLParams.IAPPSTATEPARAM}=${sAppStateKey}`);\n\t} else {\n\t\t// Add the iAppState parameter in the hash\n\t\tif (sHash.indexOf(\"?\") < 0) {\n\t\t\tsNewHash = `${sHash}?`;\n\t\t} else {\n\t\t\tsNewHash = `${sHash}&`;\n\t\t}\n\t\tsNewHash += `${enumURLParams.IAPPSTATEPARAM}=${sAppStateKey}`;\n\t}\n\n\treturn sNewHash;\n}\n\n@defineUI5Class(\"sap.fe.core.RouterProxy\")\nclass RouterProxy extends BaseObject {\n\tbIsRebuildHistoryRunning = false;\n\tbIsComputingTitleHierachy = false;\n\tbIsGuardCrossAllowed = false;\n\tsIAppStateKey: string | null = null;\n\t_oShellServices!: IShellServices;\n\tfclEnabled!: boolean;\n\t_fnBlockingNavFilter!: Function;\n\t_fnHashGuard!: Function;\n\t_bDisableOnHashChange!: boolean;\n\t_bIgnoreRestore!: boolean;\n\t_bForceFocus!: boolean;\n\t_oRouter!: Router;\n\t_oManagedHistory!: any[];\n\t_oNavigationGuard: any;\n\toResourceBundle?: ResourceBundle;\n\t_oRouteMatchSynchronization?: Synchronization;\n\t_bActivateRouteMatchSynchro: boolean = false;\n\t_bApplyRestore: boolean = false;\n\t_bDelayedRebuild: boolean = false;\n\t_pathMappings: { oldPath: string; newPath: string }[] = [];\n\n\tinit(oAppComponent: any, isfclEnabled: boolean) {\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(() => {\n\t\t\t\tthis._oShellServices = oAppComponent.getShellServices();\n\n\t\t\t\tthis.initRaw(oAppComponent.getRouter());\n\t\t\t\t// We want to wait until the initial routeMatched is done before doing any navigation\n\t\t\t\tthis.waitForRouteMatchBeforeNavigation();\n\n\t\t\t\t// Set feLevel=0 for the first Application page in the history\n\t\t\t\thistory.replaceState(\n\t\t\t\t\tObject.assign(\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tfeLevel: 0\n\t\t\t\t\t\t},\n\t\t\t\t\t\thistory.state\n\t\t\t\t\t),\n\t\t\t\t\t\"\",\n\t\t\t\t\twindow.location as any\n\t\t\t\t);\n\t\t\t\tthis.fclEnabled = isfclEnabled;\n\n\t\t\t\tthis._fnBlockingNavFilter = this._blockingNavigationFilter.bind(this);\n\t\t\t\tthis._oShellServices.registerNavigationFilter(this._fnBlockingNavFilter);\n\t\t\t})\n\t\t\t.catch(function (oError: any) {\n\t\t\t\tLog.error(\"Cannot retrieve the shell services\", oError);\n\t\t\t});\n\t\tthis._fnHashGuard = this.hashGuard.bind(this);\n\t\twindow.addEventListener(\"popstate\", this._fnHashGuard as any);\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\tdestroy() {\n\t\tif (this._oShellServices) {\n\t\t\tthis._oShellServices.unregisterNavigationFilter(this._fnBlockingNavFilter);\n\t\t}\n\t\twindow.removeEventListener(\"popstate\", this._fnHashGuard as any);\n\t}\n\n\t/**\n\t * Raw initialization (for unit tests).\n\t *\n\t * @param oRouter The router used by this proxy\n\t */\n\tinitRaw(oRouter: Router) {\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\t// Set the iAppState if the initial hash contains one\n\t\tthis.sIAppStateKey = findAppStateInHash(sCurrentAppHash);\n\t}\n\n\tgetHash() {\n\t\treturn this._oRouter.getHashChanger().getHash();\n\t}\n\n\tisFocusForced() {\n\t\treturn this._bForceFocus;\n\t}\n\n\tsetFocusForced(bForced: boolean) {\n\t\tthis._bForceFocus = bForced;\n\t}\n\n\t/**\n\t * Resets the internal variable sIAppStateKey.\n\t *\n\t * @function\n\t * @name sap.fe.core.RouterProxy#removeIAppStateKey\n\t * @ui5-restricted\n\t */\n\tremoveIAppStateKey() {\n\t\tthis.sIAppStateKey = null;\n\t}\n\n\t/**\n\t * Navigates to a specific hash.\n\t *\n\t * @function\n\t * @name sap.fe.core.RouterProxy#navToHash\n\t * @memberof sap.fe.core.RouterProxy\n\t * @static\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 * @ui5-restricted\n\t */\n\tnavToHash(\n\t\tsHash: string | undefined,\n\t\tbPreserveHistory?: boolean,\n\t\tbDisablePreservationCache?: boolean,\n\t\tbForceFocus?: boolean,\n\t\tbPreserveShellBackNavigationHandler?: boolean\n\t): Promise<boolean> {\n\t\tif (bPreserveShellBackNavigationHandler !== false) {\n\t\t\tthis._oShellServices.setBackNavigation();\n\t\t}\n\t\tif (this._oRouteMatchSynchronization) {\n\t\t\treturn this._oRouteMatchSynchronization.waitFor().then(() => {\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\t_internalNavToHash(sHash: any, bPreserveHistory: any, bDisablePreservationCache: any, bForceFocus?: boolean): Promise<boolean> {\n\t\t// Add the app state in the hash if needed\n\t\tif (this.fclEnabled && this.sIAppStateKey && !findAppStateInHash(sHash)) {\n\t\t\tsHash = 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 = (Core as CoreEx).getLibraryResourceBundle(\"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 = this._extractKeysFromHash(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: any, index: any) {\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\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 *\n\t * @returns Promise that is resolved once the history is rebuilt\n\t */\n\trestoreHistory() {\n\t\tif (this._bApplyRestore) {\n\t\t\tthis._bApplyRestore = false;\n\t\t\tlet sTargetHash = this.getHash();\n\t\t\tsTargetHash = sTargetHash.replace(/(\\?|&)restoreHistory=true/, \"\");\n\t\t\tconst oNewState = this._extractStateFromHash(sTargetHash);\n\n\t\t\tconst oHistoryAction = this._pushNewState(oNewState, true, false, true);\n\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 * Navigates back in the history.\n\t *\n\t * @returns Promise that is resolved when the navigation is finalized\n\t */\n\tnavBack() {\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 *\n\t * @param sRouteName The route name to be navigated to\n\t * @param oParameters Parameters for the navigation\n\t * @returns Promise that is resolved when the navigation is finalized\n\t * @ui5-restricted\n\t */\n\tnavTo(sRouteName: string, oParameters: any) {\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 *\n\t * @returns Promise that is resolved when we exit the app\n\t */\n\texitFromApp() {\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 *\n\t * @param sHash `true` if there is an impact\n\t * @returns If there is an impact\n\t */\n\tisCurrentStateImpactedBy(sHash: any) {\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 *\n\t * @returns `false` if a navigation has been triggered in the RouterProxy and is not yet finalized\n\t */\n\tisNavigationFinalized() {\n\t\treturn !this.bIsRebuildHistoryRunning && !this._bDelayedRebuild;\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 crosses the guard (i.e. goes to an ancestor of the guard).\n\t *\n\t * @param sHash The hash for the guard\n\t */\n\tsetNavigationGuard(sHash: string) {\n\t\tthis._oNavigationGuard = createGuardFromHash(sHash);\n\t\tthis.bIsGuardCrossAllowed = false;\n\t}\n\n\t/**\n\t * Disables the navigation guard.\n\t */\n\tdiscardNavigationGuard() {\n\t\tthis._oNavigationGuard = null;\n\t}\n\n\t/**\n\t * Checks for the availability of the navigation guard.\n\t *\n\t * @returns `true` if navigating guard is available\n\t */\n\thasNavigationGuard() {\n\t\treturn this._oNavigationGuard !== null;\n\t}\n\n\t/**\n\t * Tests a hash against the navigation guard.\n\t *\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) {\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 *\n\t * @returns `true` if crossing the guard has been allowed by the user\n\t */\n\tisGuardCrossAllowedByUser() {\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() {\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() {\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() {\n\t\tthis._oRouteMatchSynchronization = new Synchronization();\n\t\tthis._bActivateRouteMatchSynchro = false;\n\t}\n\n\t_extractKeysFromHash(sHash: any) {\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 aKeys: any[] = [];\n\n\t\taTokens.forEach(function (sToken: any) {\n\t\t\tconst regexKey = /[^\\(\\)]+\\([^\\(\\)]+\\)/; // abc(def)\n\t\t\tif (regexKey.test(sToken)) {\n\t\t\t\taKeys.push(sToken.split(\"(\")[0]);\n\t\t\t}\n\t\t});\n\n\t\treturn aKeys;\n\t}\n\n\t/**\n\t * Builds a state from a hash.\n\t *\n\t * @param sHash The hash to be used as entry\n\t * @returns The state\n\t * @ui5-restricted\n\t */\n\t_extractStateFromHash(sHash: string) {\n\t\tif (sHash === undefined) {\n\t\t\tsHash = \"\";\n\t\t}\n\n\t\tconst oState: any = {\n\t\t\tkeys: this._extractKeysFromHash(sHash)\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] : null;\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\n\t\toState.hash = sHash;\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 *\n\t * @memberof sap.fe.core.RouterProxy\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 * @ui5-restricted\n\t * @final\n\t */\n\t_pushNewState(oNewState: any, bRebuildOnly: boolean, bPreserveHistory: boolean, bDisableHistoryPreservation: boolean) {\n\t\tconst sCurrentHash = 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 = findAppStateInHash(oNewState.hash);\n\t\tif (this.fclEnabled && this.sIAppStateKey) {\n\t\t\t// In case of FCL, the new app state needs to be applied to the whole history\n\t\t\tthis._oManagedHistory.forEach((oManagedState: any) => {\n\t\t\t\toManagedState.hash = setAppStateInHash(oManagedState.hash, this.sIAppStateKey);\n\t\t\t});\n\t\t} else if (!this.fclEnabled && oLastRemovedItem) {\n\t\t\tconst sPreviousIAppStateKey = 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 = 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}\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() {\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 *\n\t * @function\n\t * @memberof sap.fe.core.RouterProxy\n\t * @ui5-restricted\n\t * @final\n\t */\n\t_disableEventOnHashChange() {\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 *\n\t * @function\n\t * @name sap.fe.core.RouterProxy#_enableEventOnHashChange\n\t * @memberof sap.fe.core.RouterProxy\n\t * @param [bIgnoreCurrentHash] Ignore the last hash event triggered before the router has initialized\n\t * @ui5-restricted\n\t * @final\n\t */\n\t_enableEventOnHashChange(bIgnoreCurrentHash: boolean | undefined) {\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 *\n\t * @memberof sap.fe.core.RouterProxy\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 * @ui5-restricted\n\t * @final\n\t */\n\t_rebuildBrowserHistory(oHistoryAction: any, 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() {\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 any)(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() {\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() {\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\t(that._oRouter.getHashChanger().replaceHash as any)(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 \"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() {\n\t\treturn this._oManagedHistory[this._oManagedHistory.length - 1];\n\t}\n\n\tsetPathMapping(mappings: { oldPath: string; newPath: string }[]) {\n\t\tthis._pathMappings = mappings.filter((mapping) => {\n\t\t\treturn mapping.oldPath !== mapping.newPath;\n\t\t});\n\t}\n\n\thashGuard() {\n\t\tlet sHash = window.location.hash;\n\n\t\tif (sHash.indexOf(\"restoreHistory=true\") !== -1) {\n\t\t\tthis._bApplyRestore = true;\n\t\t} else if (!this.bIsRebuildHistoryRunning) {\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.indexOf(m.oldPath) >= 0;\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), \"\", sHash);\n\t\t\t} else {\n\t\t\t\tconst aHashSplit = sHash.split(\"&/\");\n\t\t\t\tconst sAppHash = aHashSplit[1] ? aHashSplit[1] : \"\";\n\t\t\t\tif (this.checkHashWithGuard(sAppHash)) {\n\t\t\t\t\tthis._bDelayedRebuild = true;\n\t\t\t\t\tconst oNewState = this._extractStateFromHash(sAppHash);\n\t\t\t\t\tthis._pushNewState(oNewState, false, false, true);\n\n\t\t\t\t\tsetTimeout(() => {\n\t\t\t\t\t\tthis._bDelayedRebuild = false;\n\t\t\t\t\t}, 0);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Compares 2 states.\n\t *\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: any, oState2: any) {\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\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\t\tif (!equal) {\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 * Checks if back exits the present guard set.\n\t *\n\t * @param sPresentHash The current hash. Only used for unit tests.\n\t * @returns `true` if back exits there is a guard exit on back\n\t */\n\tcheckIfBackIsOutOfGuard(sPresentHash?: string) {\n\t\tlet sPrevHash;\n\t\tlet sCurrentHash: string;\n\t\tif (sPresentHash === undefined) {\n\t\t\t// We use window.location.hash instead of HashChanger.getInstance().getHash() because the latter\n\t\t\t// replaces characters in the URL (e.g. %24 replaced by $) and it causes issues when comparing\n\t\t\t// with the URLs in the managed history\n\t\t\tconst oSplitHash = this._oShellServices.splitHash(window.location.hash) as any;\n\t\t\tif (oSplitHash && oSplitHash.appSpecificRoute) {\n\t\t\t\tsCurrentHash = oSplitHash.appSpecificRoute;\n\t\t\t\tif (sCurrentHash.indexOf(\"&/\") === 0) {\n\t\t\t\t\tsCurrentHash = sCurrentHash.substring(2);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tsCurrentHash = window.location.hash.substring(1); // To remove the '#'\n\t\t\t\tif (sCurrentHash[0] === \"/\") {\n\t\t\t\t\tsCurrentHash = sCurrentHash.substring(1);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tsCurrentHash = sPresentHash;\n\t\t}\n\t\tsPresentHash = URI.decode(sCurrentHash);\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 === sPresentHash) {\n\t\t\t\t\tsPrevHash = 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 !sPrevHash || !this.checkHashWithGuard(sPrevHash);\n\t\t}\n\t\treturn false;\n\t}\n\n\t/**\n\t * Checks if the last 2 entries in the history share the same context.\n\t *\n\t * @returns `true` if they share the same context.\n\t */\n\tcheckIfBackHasSameContext() {\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\nexport default RouterProxy;\n"]}