@sapui5/sap.fe.core 1.99.0 → 1.100.0

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

@@ -9,28 +9,10 @@ sap.ui.define(["sap/base/Log", "sap/ui/base/Object", "sap/fe/core/Synchronizatio
 
   var UI5Class = ClassSupport.UI5Class;
 
-  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
   function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
   function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-
-  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
-  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
   var enumState = {
     EQUAL: 0,
     COMPATIBLE: 1,
@@ -112,877 +94,833 @@ sap.ui.define(["sap/base/Log", "sap/ui/base/Object", "sap/fe/core/Synchronizatio
   var RouterProxy = (_dec = UI5Class("sap.fe.core.RouterProxy"), _dec(_class = /*#__PURE__*/function (_BaseObject) {
     _inherits(RouterProxy, _BaseObject);
 
-    var _super = _createSuper(RouterProxy);
-
     function RouterProxy() {
       var _this;
 
-      _classCallCheck(this, RouterProxy);
-
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
       }
 
-      _this = _super.call.apply(_super, [this].concat(args));
+      _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;
+      return _this;
+    }
 
-      _defineProperty(_assertThisInitialized(_this), "bIsRebuildHistoryRunning", false);
+    var _proto = RouterProxy.prototype;
 
-      _defineProperty(_assertThisInitialized(_this), "bIsComputingTitleHierachy", false);
+    _proto.init = function init(oAppComponent, isfclEnabled) {
+      var _this2 = this;
 
-      _defineProperty(_assertThisInitialized(_this), "bIsGuardCrossAllowed", false);
+      // Save the name of the app (including startup parameters) for rebuilding full hashes later
+      oAppComponent.getService("shellServices").then(function () {
+        _this2._oShellServices = oAppComponent.getShellServices();
 
-      _defineProperty(_assertThisInitialized(_this), "sIAppStateKey", null);
+        _this2.initRaw(oAppComponent.getRouter()); // We want to wait until the initial routeMatched is done before doing any navigation
 
-      _defineProperty(_assertThisInitialized(_this), "_bActivateRouteMatchSynchro", false);
 
-      _defineProperty(_assertThisInitialized(_this), "_bApplyRestore", false);
+        _this2.waitForRouteMatchBeforeNavigation(); // Set feLevel=0 for the first Application page in the history
 
-      _defineProperty(_assertThisInitialized(_this), "_bDelayedRebuild", false);
 
-      return _this;
-    }
+        history.replaceState(Object.assign({
+          feLevel: 0
+        }, history.state), "", window.location);
+        _this2.fclEnabled = isfclEnabled;
+        _this2._fnBlockingNavFilter = _this2._blockingNavigationFilter.bind(_this2);
 
-    _createClass(RouterProxy, [{
-      key: "init",
-      value: function init(oAppComponent, isfclEnabled) {
-        var _this2 = this;
+        _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._bCleanedRestore = false;
+      this._bForceFocus = true; // Trigger the focus mechanism for the first view displayed by the app
+    };
 
-        // Save the name of the app (including startup parameters) for rebuilding full hashes later
-        oAppComponent.getService("shellServices").then(function () {
-          _this2._oShellServices = oAppComponent.getShellServices();
+    _proto.destroy = function destroy() {
+      if (this._oShellServices) {
+        this._oShellServices.unregisterNavigationFilter(this._fnBlockingNavFilter);
+      }
 
-          _this2.initRaw(oAppComponent.getRouter()); // We want to wait until the initial routeMatched is done before doing any navigation
+      window.removeEventListener("popstate", this._fnHashGuard);
+    }
+    /**
+     * Raw initialization (for unit tests).
+     *
+     * @param {sap.ui.core.routing.Router} oRouter The router used by this proxy
+     */
+    ;
 
+    _proto.initRaw = function initRaw(oRouter) {
+      this._oRouter = oRouter;
+      this._oManagedHistory = [];
+      this._oNavigationGuard = null;
+      var sCurrentAppHash = this.getHash();
 
-          _this2.waitForRouteMatchBeforeNavigation(); // Set feLevel=0 for the first Application page in the history
+      this._oManagedHistory.push(this._extractStateFromHash(sCurrentAppHash)); // Set the iAppState if the initial hash contains one
 
 
-          history.replaceState(Object.assign({
-            feLevel: 0
-          }, history.state), "", window.location);
-          _this2.fclEnabled = isfclEnabled;
-          _this2._fnBlockingNavFilter = _this2._blockingNavigationFilter.bind(_this2);
+      this.sIAppStateKey = findAppStateInHash(sCurrentAppHash);
+    };
+
+    _proto.getHash = function getHash() {
+      return this._oRouter.getHashChanger().getHash();
+    };
 
-          _this2._oShellServices.registerNavigationFilter(_this2._fnBlockingNavFilter);
-        }).catch(function (oError) {
-          Log.error("Cannot retrieve the shell services", oError);
+    _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 {string} sHash Hash to be navigated to
+     * @param {boolean} bPreserveHistory If set to true, non-ancestor entries in history will be retained
+     * @param {boolean} bDisablePreservationCache If set to true, cache preservation mechanism is disabled for the current navigation
+     * @param {boolean} bForceFocus If set to true, the logic to set the focus once the navigation is finalized will be triggered (onPageReady)
+     * @param {boolean} bPreserveShellBackNavigationHandler If not set to false, the back navigation is set to undefined
+     * @returns {Promise} 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);
         });
-        this._fnHashGuard = this.hashGuard.bind(this);
-        window.addEventListener("popstate", this._fnHashGuard);
-        this._bDisableOnHashChange = false;
-        this._bIgnoreRestore = false;
-        this._bCleanedRestore = false;
-        this._bForceFocus = true; // Trigger the focus mechanism for the first view displayed by the app
-      }
-    }, {
-      key: "destroy",
-      value: function destroy() {
-        if (this._oShellServices) {
-          this._oShellServices.unregisterNavigationFilter(this._fnBlockingNavFilter);
+      } else {
+        if (this._bActivateRouteMatchSynchro) {
+          this.waitForRouteMatchBeforeNavigation();
         }
 
-        window.removeEventListener("popstate", this._fnHashGuard);
+        return this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus);
       }
-      /**
-       * Raw initialization (for unit tests).
-       *
-       * @param {sap.ui.core.routing.Router} oRouter The router used by this proxy
-       */
+    };
 
-    }, {
-      key: "initRaw",
-      value: function initRaw(oRouter) {
-        this._oRouter = oRouter;
-        this._oManagedHistory = [];
-        this._oNavigationGuard = null;
-        var sCurrentAppHash = this.getHash();
+    _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);
+      }
 
-        this._oManagedHistory.push(this._extractStateFromHash(sCurrentAppHash)); // Set the iAppState if the initial hash contains one
+      if (!this.checkHashWithGuard(sHash)) {
+        if (!this.oResourceBundle) {
+          this.oResourceBundle = sap.ui.getCore().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
 
 
-        this.sIAppStateKey = findAppStateInHash(sCurrentAppHash);
-      }
-    }, {
-      key: "getHash",
-      value: function getHash() {
-        return this._oRouter.getHashChanger().getHash();
-      }
-    }, {
-      key: "isFocusForced",
-      value: function isFocusForced() {
-        return this._bForceFocus;
-      }
-    }, {
-      key: "setFocusForced",
-      value: function setFocusForced(bForced) {
-        this._bForceFocus = bForced;
-      }
-      /**
-       * Resets the internal variable sIAppStateKey.
-       *
-       * @function
-       * @name sap.fe.core.RouterProxy#removeIAppStateKey
-       *
-       * @ui5-restricted
-       */
-
-    }, {
-      key: "removeIAppStateKey",
-      value: function removeIAppStateKey() {
-        this.sIAppStateKey = null;
-      }
-      /**
-       * Navigates to a specific hash.
-       *
-       * @function
-       * @name sap.fe.core.RouterProxy#navToHash
-       * @memberof sap.fe.core.RouterProxy
-       * @static
-       * @param {string} sHash Hash to be navigated to
-       * @param {boolean} bPreserveHistory If set to true, non-ancestor entries in history will be retained
-       * @param {boolean} bDisablePreservationCache If set to true, cache preservation mechanism is disabled for the current navigation
-       * @param {boolean} bForceFocus If set to true, the logic to set the focus once the navigation is finalized will be triggered (onPageReady)
-       * @param {boolean} bPreserveShellBackNavigationHandler If not set to false, the back navigation is set to undefined
-       * @returns {Promise} Promise (resolved when the navigation is finalized) that returns 'true' if a navigation took place, 'false' if the navigation didn't happen
-       * @ui5-restricted
-       */
-
-    }, {
-      key: "navToHash",
-      value: function navToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus, bPreserveShellBackNavigationHandler) {
-        var _this3 = this;
-
-        if (bPreserveShellBackNavigationHandler !== false) {
-          this._oShellServices.setBackNavigation();
+        if (!confirm(this.oResourceBundle.getText("C_ROUTER_PROXY_SAPFE_EXIT_NOTSAVED_MESSAGE"))) {
+          // The user clicked on Cancel --> cancel navigation
+          return Promise.resolve(false);
         }
 
-        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();
-          }
+        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.
 
-          return this._internalNavToHash(sHash, bPreserveHistory, bDisablePreservationCache, bForceFocus);
-        }
-      }
-    }, {
-      key: "_internalNavToHash",
-      value: 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 = sap.ui.getCore().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
+      var oNewState = this._extractStateFromHash(sHash);
 
+      if (!this._bForceFocus) {
+        // If the focus was already forced, keep it
+        var aCurrentHashKeys = this._extractKeysFromHash(this.getHash());
 
-          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.
+        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);
 
-        var oNewState = this._extractStateFromHash(sHash);
+      return this._rebuildBrowserHistory(oHistoryAction, false);
+    }
+    /**
+     * Clears browser history if entries have been added without using the RouterProxy.
+     * Updates the internal history accordingly.
+     *
+     * @returns {Promise} Promise that is resolved once the history is rebuilt
+     */
+    ;
 
-        if (!this._bForceFocus) {
-          // If the focus was already forced, keep it
-          var aCurrentHashKeys = this._extractKeysFromHash(this.getHash());
+    _proto.restoreHistory = function restoreHistory() {
+      if (this._bApplyRestore) {
+        this._bApplyRestore = false;
+        var sTargetHash = this.getHash();
+        sTargetHash = sTargetHash.replace(/(\?|&)restoreHistory=true/, "");
 
-          this._bForceFocus = bForceFocus || aCurrentHashKeys.length < oNewState.keys.length && aCurrentHashKeys.every(function (key, index) {
-            return key === oNewState.keys[index];
-          });
-        }
+        var oNewState = this._extractStateFromHash(sTargetHash);
 
-        var oHistoryAction = this._pushNewState(oNewState, false, bPreserveHistory, bDisablePreservationCache);
+        var oHistoryAction = this._pushNewState(oNewState, true, false, true);
 
-        return this._rebuildBrowserHistory(oHistoryAction, false);
+        return this._rebuildBrowserHistory(oHistoryAction, true);
+      } else {
+        return Promise.resolve();
       }
-      /**
-       * Clears browser history if entries have been added without using the RouterProxy.
-       * Updates the internal history accordingly.
-       *
-       * @returns {Promise} Promise that is resolved once the history is rebuilt
-       */
-
-    }, {
-      key: "restoreHistory",
-      value: 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} 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;
         }
       }
-      /**
-       * Navigates back in the history.
-       *
-       * @returns {Promise} Promise that is resolved when the navigation is finalized
-       */
-
-    }, {
-      key: "navBack",
-      value: 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 {string} sRouteName The route name to be navigated to
-       * @param {object} oParameters Parameters for the navigation
-       * @returns {Promise} Promise that is resolved when the navigation is finalized
-       * @ui5-restricted
-       */
-
-    }, {
-      key: "navTo",
-      value: 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} Promise that is resolved when we exit the app
-       */
-
-    }, {
-      key: "exitFromApp",
-      value: function exitFromApp() {
-        return this._oShellServices.backToPreviousApp();
+      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();
       }
-      /**
-       * 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 {boolean} If there is an impact
-       */
-
-    }, {
-      key: "isCurrentStateImpactedBy",
-      value: function isCurrentStateImpactedBy(sHash) {
-        if (sHash[0] === "/") {
-          sHash = sHash.substring(1);
-        }
+    }
+    /**
+     * Navigates to a route with parameters.
+     * @param {string} sRouteName The route name to be navigated to
+     * @param {object} oParameters Parameters for the navigation
+     * @returns {Promise} 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} 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 {boolean} 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 {boolean} `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).
+     */
+    ;
+
+    _proto.setNavigationGuard = function setNavigationGuard() {
+      this._oNavigationGuard = createGuardFromHash(this.getHash());
+      this.bIsGuardCrossAllowed = false;
+    }
+    /**
+     * Disables the navigation guard.
+     */
+    ;
 
-        var oLocalGuard = createGuardFromHash(sHash);
-        return oLocalGuard.check(this.getHash());
-      }
-      /**
-       * Checks if a navigation is currently being processed.
-       *
-       * @returns {boolean} `false` if a navigation has been triggered in the RouterProxy and is not yet finalized
-       */
-
-    }, {
-      key: "isNavigationFinalized",
-      value: 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).
-       */
-
-    }, {
-      key: "setNavigationGuard",
-      value: function setNavigationGuard() {
-        this._oNavigationGuard = createGuardFromHash(this.getHash());
-        this.bIsGuardCrossAllowed = false;
-      }
-      /**
-       * Disables the navigation guard.
-       */
-
-    }, {
-      key: "discardNavigationGuard",
-      value: function discardNavigationGuard() {
-        this._oNavigationGuard = null;
-      }
-      /**
-       * Checks for the availability of the navigation guard.
-       *
-       * @returns {boolean} `true` if navigating guard is available
-       */
-
-    }, {
-      key: "hasNavigationGuard",
-      value: function hasNavigationGuard() {
-        return this._oNavigationGuard !== null;
-      }
-      /**
-       * Tests a hash against the navigation guard.
-       *
-       * @param {string} sHash The hash to be tested
-       * @returns {boolean} `true` if navigating to the hash doesn't cross the guard
-       */
-
-    }, {
-      key: "checkHashWithGuard",
-      value: function checkHashWithGuard(sHash) {
-        return this._oNavigationGuard === null || this._oNavigationGuard.check(sHash);
-      }
-      /**
-       * Checks if the user allowed the navigation guard to be crossed.
-       *
-       * @returns {boolean} `true` if crossing the guard has been allowed by the user
-       */
-
-    }, {
-      key: "isGuardCrossAllowedByUser",
-      value: function isGuardCrossAllowedByUser() {
-        return this.bIsGuardCrossAllowed;
+    _proto.discardNavigationGuard = function discardNavigationGuard() {
+      this._oNavigationGuard = null;
+    }
+    /**
+     * Checks for the availability of the navigation guard.
+     *
+     * @returns {boolean} `true` if navigating guard is available
+     */
+    ;
+
+    _proto.hasNavigationGuard = function hasNavigationGuard() {
+      return this._oNavigationGuard !== null;
+    }
+    /**
+     * Tests a hash against the navigation guard.
+     *
+     * @param {string} sHash The hash to be tested
+     * @returns {boolean} `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 {boolean} `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();
       }
-      /**
-       * 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.
-       */
-
-    }, {
-      key: "activateRouteMatchSynchronization",
-      value: function activateRouteMatchSynchronization() {
-        this._bActivateRouteMatchSynchro = true;
+    }
+    /**
+     * 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 = "";
       }
-      /**
-       * Resolve the routeMatch synchronization object, unlocking potential pending NavToHash calls.
-       */
-
-    }, {
-      key: "resolveRouteMatch",
-      value: function resolveRouteMatch() {
-        if (this._oRouteMatchSynchronization) {
-          this._oRouteMatchSynchronization.resolve();
+
+      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 {string} sHash The hash to be used as entry
+     * @returns {object} 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("\\?.*" + 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;
       }
-      /**
-       * Makes sure no navigation can happen before a routeMatch happened.
-       */
-
-    }, {
-      key: "waitForRouteMatchBeforeNavigation",
-      value: function waitForRouteMatchBeforeNavigation() {
-        this._oRouteMatchSynchronization = new Synchronization();
-        this._bActivateRouteMatchSynchro = false;
-      }
-    }, {
-      key: "_extractKeysFromHash",
-      value: function _extractKeysFromHash(sHash) {
-        if (sHash === undefined) {
-          sHash = "";
-        }
 
-        var sHashNoParams = sHash.split("?")[0]; // remove params
+      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 {object} oNewState The new state to be added
+     * @param {boolean} bRebuildOnly `true` if we're rebuilding the history after a shell menu navigation
+     * @param {boolean} bPreserveHistory If set to true, non-ancestor entries in history will be retained
+     * @param {boolean} bDisableHistoryPreservation Disable the mechanism to retained marked entries in cache
+     * @returns {object} 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--;
+        }
 
-        var aTokens = sHashNoParams.split("/");
-        var aKeys = [];
-        aTokens.forEach(function (sToken) {
-          var regexKey = /[^\(\)]+\([^\(\)]+\)/; // abc(def)
+        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));
 
-          if (regexKey.test(sToken)) {
-            aKeys.push(sToken.split("(")[0]);
-          }
-        });
-        return aKeys;
-      }
-      /**
-       * Builds a state from a hash.
-       *
-       * @param {string} sHash The hash to be used as entry
-       * @returns {object} The state
-       *
-       * @ui5-restricted
-       */
-
-    }, {
-      key: "_extractStateFromHash",
-      value: function _extractStateFromHash(sHash) {
-        if (sHash === undefined) {
-          sHash = "";
+          history.replaceState(Object.assign({
+            feLevel: 0
+          }, history.state), "");
         }
+      } // 2. Mark the top state as preserved if required
+
 
-        var oState = {
-          keys: this._extractKeysFromHash(sHash)
-        }; // Retrieve layout (if any)
+      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 aLayout = sHash.match(new RegExp("\\?.*" + 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;
+      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 {
-          oState.screenMode = 0;
+          break; // Ancestor or preserved state found --> we stop popping out states
         }
+      } // 4. iAppState management
 
-        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 {object} oNewState The new state to be added
-       * @param {boolean} bRebuildOnly `true` if we're rebuilding the history after a shell menu navigation
-       * @param {boolean} bPreserveHistory If set to true, non-ancestor entries in history will be retained
-       * @param {boolean} bDisableHistoryPreservation Disable the mechanism to retained marked entries in cache
-       * @returns {object} The new state
-       * @ui5-restricted
-       * @final
-       */
-
-    }, {
-      key: "_pushNewState",
-      value: 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));
+      this.sIAppStateKey = findAppStateInHash(oNewState.hash);
 
-            history.replaceState(Object.assign({
-              feLevel: 0
-            }, history.state), "");
-          }
-        } // 2. Mark the top state as preserved if required
+      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 (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
 
+        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 oLastRemovedItem;
 
-        while (this._oManagedHistory.length > 0) {
-          var oTopState = this._oManagedHistory[this._oManagedHistory.length - 1];
+      var bHasSameHash = oLastRemovedItem && oNewState.hash === oLastRemovedItem.hash;
 
-          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
+      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
 
 
-        this.sIAppStateKey = findAppStateInHash(oNewState.hash);
+      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
+        };
+      }
+    };
 
-        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);
+    _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 {boolean} [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 {object} oHistoryAction Specifies the navigation action to be performed
+     * @param {boolean} bRebuildOnly `true` if internal history is currently being rebuilt
+     * @returns {Promise} 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);
+          }
 
-          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
+          that._oRouter.getHashChanger().replaceHash(oTargetState.hash);
 
+          history.replaceState(Object.assign({
+            feLevel: newLevel
+          }, history.state), "");
 
-          if (!this.sIAppStateKey && sPreviousIAppStateKey && (oComparisonStateResult === enumState.EQUAL || oComparisonStateResult === enumState.COMPATIBLE)) {
-            oNewState.hash = setAppStateInHash(oNewState.hash, sPreviousIAppStateKey);
+          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);
           }
-        } // 5. Now we can push the state at the top of the internal history
-
 
-        var bHasSameHash = oLastRemovedItem && oNewState.hash === oLastRemovedItem.hash;
+          that.bIsRebuildHistoryRunning = false;
+          resolve(true); // a navigation occurred
+        } // Async callbacks when navigating back, in order to let all notifications and events get processed
 
-        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
 
+        function backReplaceAsync() {
+          window.removeEventListener("popstate", backReplaceAsync);
+          setTimeout(function () {
+            // Timeout to let 'hashchange' event be processed before by the HashChanger
+            replaceAsync();
+          }, 0);
+        }
 
-        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
-          };
+        function backAsync() {
+          window.removeEventListener("popstate", backAsync);
+          that.bIsRebuildHistoryRunning = false;
+          resolve(true); // a navigation occurred
         }
-      }
-    }, {
-      key: "_blockingNavigationFilter",
-      value: 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
-       */
-
-    }, {
-      key: "_disableEventOnHashChange",
-      value: 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 {boolean} [bIgnoreCurrentHash] Ignore the last hash event triggered before the router has initialized
-       *
-       * @ui5-restricted
-       * @final
-       */
-
-    }, {
-      key: "_enableEventOnHashChange",
-      value: 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 {object} oHistoryAction Specifies the navigation action to be performed
-       * @param {boolean} bRebuildOnly `true` if internal history is currently being rebuilt
-       * @returns {Promise} 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
-       */
-
-    }, {
-      key: "_rebuildBrowserHistory",
-      value: 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._bIgnoreRestore = true;
+
+        switch (oHistoryAction.type) {
+          case "replace":
             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
 
+            break;
 
-          function backReplaceAsync() {
-            window.removeEventListener("popstate", backReplaceAsync);
-            setTimeout(function () {
-              // Timeout to let 'hashchange' event be processed before by the HashChanger
-              replaceAsync();
-            }, 0);
-          }
+          case "append":
+            that._oRouter.getHashChanger().setHash(oTargetState.hash);
 
-          function backAsync() {
-            window.removeEventListener("popstate", backAsync);
+            history.replaceState(Object.assign({
+              feLevel: newLevel
+            }, history.state), "");
             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;
+            break;
 
-            case "append":
-              that._oRouter.getHashChanger().setHash(oTargetState.hash);
+          case "back":
+            window.addEventListener("popstate", backAsync);
+            history.go(-oHistoryAction.steps);
+            break;
 
-              history.replaceState(Object.assign({
-                feLevel: newLevel
-              }, history.state), "");
-              that.bIsRebuildHistoryRunning = false;
-              resolve(true); // a navigation occurred
+          case "back-replace":
+            _this5._disableEventOnHashChange();
 
-              break;
+            window.addEventListener("popstate", backReplaceAsync);
+            history.go(-oHistoryAction.steps);
+            break;
 
-            case "back":
-              window.addEventListener("popstate", backAsync);
-              history.go(-oHistoryAction.steps);
-              break;
+          default:
+            // No navigation
+            _this5.bIsRebuildHistoryRunning = false;
+            resolve(false);
+          // no navigation --> resolve to false
+        }
+      });
+    };
 
-            case "back-replace":
-              _this5._disableEventOnHashChange();
+    _proto.getLastHistoryEntry = function getLastHistoryEntry() {
+      return this._oManagedHistory[this._oManagedHistory.length - 1];
+    };
 
-              window.addEventListener("popstate", backReplaceAsync);
-              history.go(-oHistoryAction.steps);
-              break;
+    _proto.hashGuard = function hashGuard() {
+      var _this6 = this;
 
-            default:
-              // No navigation
-              _this5.bIsRebuildHistoryRunning = false;
-              resolve(false);
-            // no navigation --> resolve to false
-          }
-        });
-      }
-    }, {
-      key: "getLastHistoryEntry",
-      value: function getLastHistoryEntry() {
-        return this._oManagedHistory[this._oManagedHistory.length - 1];
+      if (this._bCleanedRestore) {
+        this._bCleanedRestore = false;
+        return;
       }
-    }, {
-      key: "hashGuard",
-      value: function hashGuard() {
-        var _this6 = this;
-
-        if (this._bCleanedRestore) {
-          this._bCleanedRestore = false;
-          return;
-        }
 
-        var sHash = window.location.hash;
+      var sHash = window.location.hash;
 
-        if (sHash.indexOf("restoreHistory=true") !== -1) {
-          this._bApplyRestore = true;
-        } else if (!this.bIsRebuildHistoryRunning) {
-          var aHashSplit = sHash.split("&/");
-          var sAppHash = aHashSplit[1] ? aHashSplit[1] : "";
+      if (sHash.indexOf("restoreHistory=true") !== -1) {
+        this._bApplyRestore = true;
+      } else if (!this.bIsRebuildHistoryRunning) {
+        var aHashSplit = sHash.split("&/");
+        var sAppHash = aHashSplit[1] ? aHashSplit[1] : "";
 
-          if (this.checkHashWithGuard(sAppHash)) {
-            this._bDelayedRebuild = true;
+        if (this.checkHashWithGuard(sAppHash)) {
+          this._bDelayedRebuild = true;
 
-            var oNewState = this._extractStateFromHash(sAppHash);
+          var oNewState = this._extractStateFromHash(sAppHash);
 
-            this._pushNewState(oNewState, false, false, true);
+          this._pushNewState(oNewState, false, false, true);
 
-            setTimeout(function () {
-              _this6._bDelayedRebuild = false;
-            }, 0);
-          }
+          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
-       */
-
-    }, {
-      key: "_compareCacheStates",
-      value: function _compareCacheStates(oState1, oState2) {
-        // First compare object keys
-        if (oState1.keys.length > oState2.keys.length) {
-          return enumState.DIFFERENT;
+    }
+    /**
+     * 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;
         }
+      }
 
-        var equal = true;
-        var index;
+      if (!equal) {
+        // Some objects keys are different
+        return enumState.DIFFERENT;
+      } // All keys from oState1 are in oState2 --> check if ancestor
 
-        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
 
-        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 {string} sPresentHash The current hash. Only used for unit tests.
+     * @returns {boolean} `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 '#'
 
-        return oState1.sLayout === oState2.sLayout ? enumState.EQUAL : enumState.COMPATIBLE;
-      }
-      /**
-       * Checks if back exits the present guard set.
-       *
-       * @param {string} sPresentHash The current hash. Only used for unit tests.
-       * @returns {boolean} `true` if back exits there is a guard exit on back
-       */
-
-    }, {
-      key: "checkIfBackIsOutOfGuard",
-      value: function checkIfBackIsOutOfGuard(sPresentHash) {
-        var sPrevHash;
-
-        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) {
-            sPresentHash = oSplitHash.appSpecificRoute;
-
-            if (sPresentHash.indexOf("&/") === 0) {
-              sPresentHash = sPresentHash.substring(2);
-            }
-          } else {
-            sPresentHash = window.location.hash.substring(1); // To remove the '#'
-
-            if (sPresentHash[0] === "/") {
-              sPresentHash = sPresentHash.substring(1);
-            }
+          if (sCurrentHash[0] === "/") {
+            sCurrentHash = sCurrentHash.substring(1);
           }
         }
+      } else {
+        sCurrentHash = sPresentHash;
+      }
 
-        sPresentHash = URI.decode(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;
-            }
+      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;
+        return !sPrevHash || !this.checkHashWithGuard(sPrevHash);
       }
-      /**
-       * Checks if the last 2 entries in the history share the same context.
-       *
-       * @returns {boolean} `true` if they share the same context.
-       */
-
-    }, {
-      key: "checkIfBackHasSameContext",
-      value: 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 false;
+    }
+    /**
+     * Checks if the last 2 entries in the history share the same context.
+     *
+     * @returns {boolean} `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","UI5Class","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","_bCleanedRestore","_bForceFocus","unregisterNavigationFilter","removeEventListener","oRouter","_oRouter","_oManagedHistory","_oNavigationGuard","sCurrentAppHash","getHash","push","_extractStateFromHash","sIAppStateKey","getHashChanger","bForced","bPreserveHistory","bDisablePreservationCache","bForceFocus","bPreserveShellBackNavigationHandler","setBackNavigation","_oRouteMatchSynchronization","waitFor","undefined","_internalNavToHash","_bActivateRouteMatchSynchro","checkHashWithGuard","oResourceBundle","sap","ui","getCore","getLibraryResourceBundle","confirm","getText","Promise","resolve","bIsGuardCrossAllowed","oNewState","aCurrentHashKeys","_extractKeysFromHash","keys","every","key","index","oHistoryAction","_pushNewState","_rebuildBrowserHistory","_bApplyRestore","sTargetHash","sCurrentHash","sPreviousHash","i","hash","navToHash","back","sRouteName","oParameters","getURL","noPreservationCache","bIsStickyMode","backToPreviousApp","substring","oLocalGuard","bIsRebuildHistoryRunning","_bDelayedRebuild","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","stop","bIgnoreCurrentHash","initialize","that","oTargetState","newLevel","replaceAsync","_enableEventOnHashChange","replaceHash","setTimeout","backReplaceAsync","backAsync","setHash","go","_disableEventOnHashChange","aHashSplit","sAppHash","oState1","oState2","equal","sPresentHash","sPrevHash","oSplitHash","splitHash","appSpecificRoute","URI","decode","oCurrentState","oPreviousState","BaseObject"],"mappings":"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","sourceRoot":".","sourcesContent":["import Log from \"sap/base/Log\";\nimport BaseObject from \"sap/ui/base/Object\";\nimport Synchronization from \"sap/fe/core/Synchronization\";\nimport URI from \"sap/ui/thirdparty/URI\";\nimport { IShellServices } from \"sap/fe/core/services/ShellServicesFactory\";\nimport Router from \"sap/ui/core/routing/Router\";\nimport { UI5Class } from \"sap/fe/core/helpers/ClassSupport\";\nimport ResourceBundle from \"sap/base/i18n/ResourceBundle\";\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 {string} sGuardHash The hash used for the guard\n * @returns {object} 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 {string} sHash The hash\n * @returns {string} 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 {string} sHash The hash\n * @returns {string} 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 {string} 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@UI5Class(\"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_bCleanedRestore!: 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\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._bCleanedRestore = 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 {sap.ui.core.routing.Router} 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 *\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 {string} sHash Hash to be navigated to\n\t * @param {boolean} bPreserveHistory If set to true, non-ancestor entries in history will be retained\n\t * @param {boolean} bDisablePreservationCache If set to true, cache preservation mechanism is disabled for the current navigation\n\t * @param {boolean} bForceFocus If set to true, the logic to set the focus once the navigation is finalized will be triggered (onPageReady)\n\t * @param {boolean} bPreserveShellBackNavigationHandler If not set to false, the back navigation is set to undefined\n\t * @returns {Promise} 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) {\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) {\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 = sap.ui.getCore().getLibraryResourceBundle(\"sap.fe.core\") as ResourceBundle;\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} 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} 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 * @param {string} sRouteName The route name to be navigated to\n\t * @param {object} oParameters Parameters for the navigation\n\t * @returns {Promise} 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} 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 {boolean} 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 {boolean} `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\tsetNavigationGuard() {\n\t\tthis._oNavigationGuard = createGuardFromHash(this.getHash());\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 {boolean} `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 {string} sHash The hash to be tested\n\t * @returns {boolean} `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 {boolean} `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 {string} sHash The hash to be used as entry\n\t * @returns {object} The state\n\t *\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 {object} oNewState The new state to be added\n\t * @param {boolean} bRebuildOnly `true` if we're rebuilding the history after a shell menu navigation\n\t * @param {boolean} bPreserveHistory If set to true, non-ancestor entries in history will be retained\n\t * @param {boolean} bDisableHistoryPreservation Disable the mechanism to retained marked entries in cache\n\t * @returns {object} 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 *\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 {boolean} [bIgnoreCurrentHash] Ignore the last hash event triggered before the router has initialized\n\t *\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 {object} oHistoryAction Specifies the navigation action to be performed\n\t * @param {boolean} bRebuildOnly `true` if internal history is currently being rebuilt\n\t * @returns {Promise} 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) {\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\thashGuard() {\n\t\tif (this._bCleanedRestore) {\n\t\t\tthis._bCleanedRestore = false;\n\t\t\treturn;\n\t\t}\n\t\tconst sHash = window.location.hash;\n\t\tif (sHash.indexOf(\"restoreHistory=true\") !== -1) {\n\t\t\tthis._bApplyRestore = true;\n\t\t} else if (!this.bIsRebuildHistoryRunning) {\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\tthis._bDelayedRebuild = true;\n\t\t\t\tconst oNewState = this._extractStateFromHash(sAppHash);\n\t\t\t\tthis._pushNewState(oNewState, false, false, true);\n\n\t\t\t\tsetTimeout(() => {\n\t\t\t\t\tthis._bDelayedRebuild = false;\n\t\t\t\t}, 0);\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 {string} sPresentHash The current hash. Only used for unit tests.\n\t * @returns {boolean} `true` if back exits there is a guard exit on back\n\t */\n\tcheckIfBackIsOutOfGuard(sPresentHash: string) {\n\t\tlet sPrevHash;\n\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\tsPresentHash = oSplitHash.appSpecificRoute;\n\t\t\t\tif (sPresentHash.indexOf(\"&/\") === 0) {\n\t\t\t\t\tsPresentHash = sPresentHash.substring(2);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tsPresentHash = window.location.hash.substring(1); // To remove the '#'\n\t\t\t\tif (sPresentHash[0] === \"/\") {\n\t\t\t\t\tsPresentHash = sPresentHash.substring(1);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tsPresentHash = URI.decode(sPresentHash);\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 {boolean} `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"]}
+//# 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","UI5Class","bIsRebuildHistoryRunning","bIsComputingTitleHierachy","bIsGuardCrossAllowed","sIAppStateKey","_bActivateRouteMatchSynchro","_bApplyRestore","_bDelayedRebuild","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","_bCleanedRestore","_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","sap","ui","getCore","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","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 Log from \"sap/base/Log\";\nimport BaseObject from \"sap/ui/base/Object\";\nimport Synchronization from \"sap/fe/core/Synchronization\";\nimport URI from \"sap/ui/thirdparty/URI\";\nimport { IShellServices } from \"sap/fe/core/services/ShellServicesFactory\";\nimport Router from \"sap/ui/core/routing/Router\";\nimport { UI5Class } from \"sap/fe/core/helpers/ClassSupport\";\nimport ResourceBundle from \"sap/base/i18n/ResourceBundle\";\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 {string} sGuardHash The hash used for the guard\n * @returns {object} 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 {string} sHash The hash\n * @returns {string} 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 {string} sHash The hash\n * @returns {string} 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 {string} 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@UI5Class(\"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_bCleanedRestore!: 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\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._bCleanedRestore = 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 {sap.ui.core.routing.Router} 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 *\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 {string} sHash Hash to be navigated to\n\t * @param {boolean} bPreserveHistory If set to true, non-ancestor entries in history will be retained\n\t * @param {boolean} bDisablePreservationCache If set to true, cache preservation mechanism is disabled for the current navigation\n\t * @param {boolean} bForceFocus If set to true, the logic to set the focus once the navigation is finalized will be triggered (onPageReady)\n\t * @param {boolean} bPreserveShellBackNavigationHandler If not set to false, the back navigation is set to undefined\n\t * @returns {Promise} 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) {\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) {\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 = sap.ui.getCore().getLibraryResourceBundle(\"sap.fe.core\") as ResourceBundle;\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} 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} 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 * @param {string} sRouteName The route name to be navigated to\n\t * @param {object} oParameters Parameters for the navigation\n\t * @returns {Promise} 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} 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 {boolean} 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 {boolean} `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\tsetNavigationGuard() {\n\t\tthis._oNavigationGuard = createGuardFromHash(this.getHash());\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 {boolean} `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 {string} sHash The hash to be tested\n\t * @returns {boolean} `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 {boolean} `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 {string} sHash The hash to be used as entry\n\t * @returns {object} The state\n\t *\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 {object} oNewState The new state to be added\n\t * @param {boolean} bRebuildOnly `true` if we're rebuilding the history after a shell menu navigation\n\t * @param {boolean} bPreserveHistory If set to true, non-ancestor entries in history will be retained\n\t * @param {boolean} bDisableHistoryPreservation Disable the mechanism to retained marked entries in cache\n\t * @returns {object} 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 *\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 {boolean} [bIgnoreCurrentHash] Ignore the last hash event triggered before the router has initialized\n\t *\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 {object} oHistoryAction Specifies the navigation action to be performed\n\t * @param {boolean} bRebuildOnly `true` if internal history is currently being rebuilt\n\t * @returns {Promise} 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) {\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\thashGuard() {\n\t\tif (this._bCleanedRestore) {\n\t\t\tthis._bCleanedRestore = false;\n\t\t\treturn;\n\t\t}\n\t\tconst sHash = window.location.hash;\n\t\tif (sHash.indexOf(\"restoreHistory=true\") !== -1) {\n\t\t\tthis._bApplyRestore = true;\n\t\t} else if (!this.bIsRebuildHistoryRunning) {\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\tthis._bDelayedRebuild = true;\n\t\t\t\tconst oNewState = this._extractStateFromHash(sAppHash);\n\t\t\t\tthis._pushNewState(oNewState, false, false, true);\n\n\t\t\t\tsetTimeout(() => {\n\t\t\t\t\tthis._bDelayedRebuild = false;\n\t\t\t\t}, 0);\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 {string} sPresentHash The current hash. Only used for unit tests.\n\t * @returns {boolean} `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 {boolean} `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"]}