@sapui5/sap.fe.core 1.110.0 → 1.111.0

package/src/sap/fe/core/controllerextensions/InternalRouting-dbg.js

@@ -0,0 +1,984 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2023 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/Log", "sap/fe/core/CommonUtils", "sap/fe/core/controllerextensions/BusyLocker", "sap/fe/core/controllerextensions/collaboration/ActivitySync", "sap/fe/core/controllerextensions/editFlow/draft", "sap/fe/core/controllerextensions/routing/NavigationReason", "sap/fe/core/helpers/ClassSupport", "sap/fe/core/helpers/EditState", "sap/fe/core/helpers/ModelHelper", "sap/fe/core/helpers/SemanticKeyHelper", "sap/ui/core/Component", "sap/ui/core/Core", "sap/ui/core/mvc/ControllerExtension", "sap/ui/core/mvc/OverrideExecution", "sap/ui/model/Filter", "sap/ui/model/FilterOperator"], function (Log, CommonUtils, BusyLocker, ActivitySync, draft, NavigationReason, ClassSupport, EditState, ModelHelper, SemanticKeyHelper, Component, Core, ControllerExtension, OverrideExecution, Filter, FilterOperator) {
+  "use strict";
+
+  var _dec, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec10, _dec11, _dec12, _dec13, _dec14, _dec15, _dec16, _dec17, _dec18, _dec19, _dec20, _dec21, _dec22, _dec23, _dec24, _dec25, _dec26, _dec27, _dec28, _dec29, _dec30, _class, _class2;
+  var publicExtension = ClassSupport.publicExtension;
+  var methodOverride = ClassSupport.methodOverride;
+  var finalExtension = ClassSupport.finalExtension;
+  var extensible = ClassSupport.extensible;
+  var defineUI5Class = ClassSupport.defineUI5Class;
+  var isConnected = ActivitySync.isConnected;
+  function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
+  /**
+   * {@link sap.ui.core.mvc.ControllerExtension Controller extension}
+   *
+   * @namespace
+   * @alias sap.fe.core.controllerextensions.InternalRouting
+   * @private
+   * @since 1.74.0
+   */
+  let InternalRouting = (_dec = defineUI5Class("sap.fe.core.controllerextensions.InternalRouting"), _dec2 = methodOverride(), _dec3 = methodOverride(), _dec4 = publicExtension(), _dec5 = extensible(OverrideExecution.After), _dec6 = publicExtension(), _dec7 = extensible(OverrideExecution.After), _dec8 = publicExtension(), _dec9 = extensible(OverrideExecution.After), _dec10 = publicExtension(), _dec11 = extensible(OverrideExecution.After), _dec12 = publicExtension(), _dec13 = publicExtension(), _dec14 = publicExtension(), _dec15 = finalExtension(), _dec16 = publicExtension(), _dec17 = finalExtension(), _dec18 = publicExtension(), _dec19 = finalExtension(), _dec20 = publicExtension(), _dec21 = finalExtension(), _dec22 = publicExtension(), _dec23 = finalExtension(), _dec24 = publicExtension(), _dec25 = finalExtension(), _dec26 = publicExtension(), _dec27 = publicExtension(), _dec28 = finalExtension(), _dec29 = publicExtension(), _dec30 = extensible(OverrideExecution.Before), _dec(_class = (_class2 = /*#__PURE__*/function (_ControllerExtension) {
+    _inheritsLoose(InternalRouting, _ControllerExtension);
+    function InternalRouting() {
+      return _ControllerExtension.apply(this, arguments) || this;
+    }
+    var _proto = InternalRouting.prototype;
+    _proto.onExit = function onExit() {
+      if (this._oRoutingService) {
+        this._oRoutingService.detachRouteMatched(this._fnRouteMatchedBound);
+      }
+    };
+    _proto.onInit = function onInit() {
+      this._oView = this.base.getView();
+      this._oAppComponent = CommonUtils.getAppComponent(this._oView);
+      this._oPageComponent = Component.getOwnerComponentFor(this._oView);
+      this._oRouter = this._oAppComponent.getRouter();
+      this._oRouterProxy = this._oAppComponent.getRouterProxy();
+      if (!this._oAppComponent || !this._oPageComponent) {
+        throw new Error("Failed to initialize controler extension 'sap.fe.core.controllerextesions.InternalRouting");
+      }
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      if (this._oAppComponent === this._oPageComponent) {
+        // The view isn't hosted in a dedicated UIComponent, but directly in the app
+        // --> just keep the view
+        this._oPageComponent = null;
+      }
+      this._oAppComponent.getService("routingService").then(oRoutingService => {
+        this._oRoutingService = oRoutingService;
+        this._fnRouteMatchedBound = this._onRouteMatched.bind(this);
+        this._oRoutingService.attachRouteMatched(this._fnRouteMatchedBound);
+        this._oTargetInformation = oRoutingService.getTargetInformationFor(this._oPageComponent || this._oView);
+      }).catch(function () {
+        throw new Error("This controller extension cannot work without a 'routingService' on the main AppComponent");
+      });
+    }
+
+    /**
+     * Triggered every time this controller is a navigation target.
+     */;
+    _proto.onRouteMatched = function onRouteMatched() {
+      /**/
+    };
+    _proto.onRouteMatchedFinished = function onRouteMatchedFinished() {
+      /**/
+    };
+    _proto.onBeforeBinding = function onBeforeBinding(oBindingContext, mParameters) {
+      const oRouting = this.base.getView().getController().routing;
+      if (oRouting && oRouting.onBeforeBinding) {
+        oRouting.onBeforeBinding(oBindingContext, mParameters);
+      }
+    };
+    _proto.onAfterBinding = function onAfterBinding(oBindingContext, mParameters) {
+      this._oAppComponent.getRootViewController().onContextBoundToView(oBindingContext);
+      const oRouting = this.base.getView().getController().routing;
+      if (oRouting && oRouting.onAfterBinding) {
+        oRouting.onAfterBinding(oBindingContext, mParameters);
+      }
+    }
+
+    ///////////////////////////////////////////////////////////
+    // Methods triggering a navigation after a user action
+    // (e.g. click on a table row, button, etc...)
+    ///////////////////////////////////////////////////////////
+
+    /**
+     * Navigates to the specified navigation target.
+     *
+     * @param oContext Context instance
+     * @param sNavigationTargetName Name of the navigation target
+     * @param bPreserveHistory True to force the new URL to be added at the end of the browser history (no replace)
+     * @ui5-restricted
+     */;
+    _proto.navigateToTarget = function navigateToTarget(oContext, sNavigationTargetName, bPreserveHistory) {
+      const oNavigationConfiguration = this._oPageComponent && this._oPageComponent.getNavigationConfiguration && this._oPageComponent.getNavigationConfiguration(sNavigationTargetName);
+      if (oNavigationConfiguration) {
+        const oDetailRoute = oNavigationConfiguration.detail;
+        const sRouteName = oDetailRoute.route;
+        const mParameterMapping = oDetailRoute.parameters;
+        this._oRoutingService.navigateTo(oContext, sRouteName, mParameterMapping, bPreserveHistory);
+      } else {
+        this._oRoutingService.navigateTo(oContext, null, null, bPreserveHistory);
+      }
+      this._oView.getViewData();
+    }
+
+    /**
+     * Navigates to the specified navigation target route.
+     *
+     * @param sTargetRouteName Name of the target route
+     * @param [oParameters] Parameters to be used with route to create the target hash
+     * @returns Promise that is resolved when the navigation is finalized
+     * @ui5-restricted
+     */;
+    _proto.navigateToRoute = function navigateToRoute(sTargetRouteName, oParameters) {
+      return this._oRoutingService.navigateToRoute(sTargetRouteName, oParameters);
+    }
+
+    /**
+     * Navigates to a specific context.
+     *
+     * @param oContext The context to be navigated to
+     * @param [mParameters] Optional navigation parameters
+     * @returns Promise resolved when the navigation has been triggered
+     * @ui5-restricted
+     */;
+    _proto.navigateToContext = function navigateToContext(oContext, mParameters) {
+      const oContextInfo = {};
+      mParameters = mParameters || {};
+      if (oContext.isA("sap.ui.model.odata.v4.ODataListBinding")) {
+        if (mParameters.asyncContext) {
+          // the context is either created async (Promise)
+          // We need to activate the routeMatchSynchro on the RouterProxy to avoid that
+          // the subsequent call to navigateToContext conflicts with the current one
+          this._oRouterProxy.activateRouteMatchSynchronization();
+          mParameters.asyncContext.then(asyncContext => {
+            // once the context is returned we navigate into it
+            this.navigateToContext(asyncContext, {
+              checkNoHashChange: mParameters.checkNoHashChange,
+              editable: mParameters.editable,
+              bPersistOPScroll: mParameters.bPersistOPScroll,
+              updateFCLLevel: mParameters.updateFCLLevel,
+              bForceFocus: mParameters.bForceFocus
+            });
+          }).catch(function (oError) {
+            Log.error("Error with the async context", oError);
+          });
+        } else if (!mParameters.bDeferredContext) {
+          // Navigate to a list binding not yet supported
+          throw "navigation to a list binding is not yet supported";
+        }
+      }
+      if (mParameters.callExtension) {
+        const oInternalModel = this._oView.getModel("internal");
+        oInternalModel.setProperty("/paginatorCurrentContext", null);
+        oContextInfo.sourceBindingContext = oContext.getObject();
+        oContextInfo.bindingContext = oContext;
+        if (mParameters.oEvent) {
+          oContextInfo.oEvent = mParameters.oEvent;
+        }
+        // Storing the selected context to use it in internal route navigation if neccessary.
+        const bOverrideNav = this.base.getView().getController().routing.onBeforeNavigation(oContextInfo);
+        if (bOverrideNav) {
+          oInternalModel.setProperty("/paginatorCurrentContext", oContext);
+          return Promise.resolve(true);
+        }
+      }
+      mParameters.FCLLevel = this._getFCLLevel();
+      return this._oRoutingService.navigateToContext(oContext, mParameters, this._oView.getViewData(), this._oTargetInformation);
+    }
+
+    /**
+     * Navigates backwards from a context.
+     *
+     * @param oContext Context to be navigated from
+     * @param [mParameters] Optional navigation parameters
+     * @returns Promise resolved when the navigation has been triggered
+     * @ui5-restricted
+     */;
+    _proto.navigateBackFromContext = function navigateBackFromContext(oContext, mParameters) {
+      mParameters = mParameters || {};
+      mParameters.updateFCLLevel = -1;
+      return this.navigateToContext(oContext, mParameters);
+    }
+
+    /**
+     * Navigates forwards to a context.
+     *
+     * @param oContext Context to be navigated to
+     * @param mParameters Optional navigation parameters
+     * @returns Promise resolved when the navigation has been triggered
+     * @ui5-restricted
+     */;
+    _proto.navigateForwardToContext = function navigateForwardToContext(oContext, mParameters) {
+      var _this$_oView$getBindi;
+      if (((_this$_oView$getBindi = this._oView.getBindingContext("internal")) === null || _this$_oView$getBindi === void 0 ? void 0 : _this$_oView$getBindi.getProperty("messageFooterContainsErrors")) === true) {
+        return Promise.resolve(true);
+      }
+      mParameters = mParameters || {};
+      mParameters.updateFCLLevel = 1;
+      return this.navigateToContext(oContext, mParameters);
+    }
+
+    /**
+     * Navigates back in history if the current hash corresponds to a transient state.
+     */;
+    _proto.navigateBackFromTransientState = function navigateBackFromTransientState() {
+      const sHash = this._oRouterProxy.getHash();
+
+      // if triggered while navigating to (...), we need to navigate back
+      if (sHash.indexOf("(...)") !== -1) {
+        this._oRouterProxy.navBack();
+      }
+    };
+    _proto.navigateToMessagePage = function navigateToMessagePage(sErrorMessage, mParameters) {
+      mParameters = mParameters || {};
+      if (this._oRouterProxy.getHash().indexOf("i-action=create") > -1 || this._oRouterProxy.getHash().indexOf("i-action=autoCreate") > -1) {
+        return this._oRouterProxy.navToHash(this._oRoutingService.getDefaultCreateHash());
+      } else {
+        mParameters.FCLLevel = this._getFCLLevel();
+        return this._oAppComponent.getRootViewController().displayErrorPage(sErrorMessage, mParameters);
+      }
+    }
+
+    /**
+     * Checks if one of the current views on the screen is bound to a given context.
+     *
+     * @param oContext
+     * @returns `true` if the state is impacted by the context
+     * @ui5-restricted
+     */;
+    _proto.isCurrentStateImpactedBy = function isCurrentStateImpactedBy(oContext) {
+      return this._oRoutingService.isCurrentStateImpactedBy(oContext);
+    };
+    _proto._isViewPartOfRoute = function _isViewPartOfRoute(routeInformation) {
+      const aTargets = routeInformation === null || routeInformation === void 0 ? void 0 : routeInformation.targets;
+      if (!aTargets || aTargets.indexOf(this._oTargetInformation.targetName) === -1) {
+        // If the target for this view has a view level greater than the route level, it means this view comes "after" the route
+        // in terms of navigation.
+        // In such case, we remove its binding context, to avoid this view to have data if we navigate to it later on
+        if ((this._oTargetInformation.viewLevel ?? 0) >= ((routeInformation === null || routeInformation === void 0 ? void 0 : routeInformation.routeLevel) ?? 0)) {
+          this._setBindingContext(null); // This also call setKeepAlive(false) on the current context
+        }
+
+        return false;
+      }
+      return true;
+    };
+    _proto._buildBindingPath = function _buildBindingPath(routeArguments, bindingPattern, navigationParameters) {
+      let path = bindingPattern.replace(":?query:", "");
+      let deferred = false;
+      for (const sKey in routeArguments) {
+        const sValue = routeArguments[sKey];
+        if (sValue === "..." && bindingPattern.indexOf(`{${sKey}}`) >= 0) {
+          deferred = true;
+          // Sometimes in preferredMode = create, the edit button is shown in background when the
+          // action parameter dialog shows up, setting bTargetEditable passes editable as true
+          // to onBeforeBinding in _bindTargetPage function
+          navigationParameters.bTargetEditable = true;
+        }
+        path = path.replace(`{${sKey}}`, sValue);
+      }
+      if (routeArguments["?query"] && routeArguments["?query"].hasOwnProperty("i-action")) {
+        navigationParameters.bActionCreate = true;
+      }
+
+      // the binding path is always absolute
+      if (path && path[0] !== "/") {
+        path = `/${path}`;
+      }
+      return {
+        path,
+        deferred
+      };
+    }
+
+    ///////////////////////////////////////////////////////////
+    // Methods to bind the page when a route is matched
+    ///////////////////////////////////////////////////////////
+
+    /**
+     * Called when a route is matched.
+     * Builds the binding context from the navigation parameters, and bind the page accordingly.
+     *
+     * @param oEvent
+     * @ui5-restricted
+     */;
+    _proto._onRouteMatched = function _onRouteMatched(oEvent) {
+      // Check if the target for this view is part of the event targets (i.e. is a target for the current route).
+      // If not, we don't need to bind it --> return
+      if (!this._isViewPartOfRoute(oEvent.getParameter("routeInformation"))) {
+        return;
+      }
+
+      // Retrieve the binding context pattern
+      let bindingPattern;
+      if (this._oPageComponent && this._oPageComponent.getBindingContextPattern) {
+        bindingPattern = this._oPageComponent.getBindingContextPattern();
+      }
+      bindingPattern = bindingPattern || this._oTargetInformation.contextPattern;
+      if (bindingPattern === null || bindingPattern === undefined) {
+        // Don't do this if we already got sTarget == '', which is a valid target pattern
+        bindingPattern = oEvent.getParameter("routePattern");
+      }
+
+      // Replace the parameters by their values in the binding context pattern
+      const mArguments = oEvent.getParameters().arguments;
+      const oNavigationParameters = oEvent.getParameter("navigationInfo");
+      const {
+        path,
+        deferred
+      } = this._buildBindingPath(mArguments, bindingPattern, oNavigationParameters);
+      this.onRouteMatched();
+      const oModel = this._oView.getModel();
+      let oOut;
+      if (deferred) {
+        oOut = this._bindDeferred(path, oNavigationParameters);
+      } else {
+        oOut = this._bindPage(path, oModel, oNavigationParameters);
+      }
+      // eslint-disable-next-line promise/catch-or-return
+      oOut.finally(() => {
+        this.onRouteMatchedFinished();
+      });
+      this._oAppComponent.getRootViewController().updateUIStateForView(this._oView, this._getFCLLevel());
+    }
+
+    /**
+     * Deferred binding (during object creation).
+     *
+     * @param sTargetPath The path to the deffered context
+     * @param oNavigationParameters Navigation parameters
+     * @returns A Promise
+     * @ui5-restricted
+     */;
+    _proto._bindDeferred = function _bindDeferred(sTargetPath, oNavigationParameters) {
+      this.onBeforeBinding(null, {
+        editable: oNavigationParameters.bTargetEditable
+      });
+      if (oNavigationParameters.bDeferredContext || !oNavigationParameters.oAsyncContext) {
+        // either the context shall be created in the target page (deferred Context) or it shall
+        // be created async but the user refreshed the page / bookmarked this URL
+        // TODO: currently the target component creates this document but we shall move this to
+        // a central place
+        if (this._oPageComponent && this._oPageComponent.createDeferredContext) {
+          this._oPageComponent.createDeferredContext(sTargetPath, oNavigationParameters.useContext, oNavigationParameters.bActionCreate);
+        }
+      }
+      const currentBindingContext = this._getBindingContext();
+      if (currentBindingContext !== null && currentBindingContext !== void 0 && currentBindingContext.hasPendingChanges()) {
+        // For now remove the pending changes to avoid the model raises errors and the object page is at least bound
+        // Ideally the user should be asked for
+        currentBindingContext.getBinding().resetChanges();
+      }
+
+      // remove the context to avoid showing old data
+      this._setBindingContext(null);
+      this.onAfterBinding(null);
+      return Promise.resolve();
+    }
+
+    /**
+     * Sets the binding context of the page from a path.
+     *
+     * @param sTargetPath The path to the context
+     * @param oModel The OData model
+     * @param oNavigationParameters Navigation parameters
+     * @returns A Promise resolved once the binding has been set on the page
+     * @ui5-restricted
+     */;
+    _proto._bindPage = function _bindPage(sTargetPath, oModel, oNavigationParameters) {
+      if (sTargetPath === "") {
+        return Promise.resolve(this._bindPageToContext(null, oModel, oNavigationParameters));
+      } else {
+        return this._resolveSemanticPath(sTargetPath, oModel).then(sTechnicalPath => {
+          this._bindPageToPath(sTechnicalPath, oModel, oNavigationParameters);
+        }).catch(oError => {
+          // Error handling for erroneous metadata request
+          const oResourceBundle = Core.getLibraryResourceBundle("sap.fe.core");
+          this.navigateToMessagePage(oResourceBundle.getText("C_COMMON_SAPFE_DATA_RECEIVED_ERROR"), {
+            title: oResourceBundle.getText("C_COMMON_SAPFE_ERROR"),
+            description: oError.message
+          });
+        });
+      }
+    }
+
+    /**
+     * Creates the filter to retrieve a context corresponding to a semantic path.
+     *
+     * @param sSemanticPath The semantic path
+     * @param aSemanticKeys The semantic keys for the path
+     * @param oMetaModel The instance of the meta model
+     * @returns The filter
+     * @ui5-restricted
+     */;
+    _proto._createFilterFromSemanticPath = function _createFilterFromSemanticPath(sSemanticPath, aSemanticKeys, oMetaModel) {
+      const fnUnquoteAndDecode = function (sValue) {
+        if (sValue.indexOf("'") === 0 && sValue.lastIndexOf("'") === sValue.length - 1) {
+          // Remove the quotes from the value and decode special chars
+          sValue = decodeURIComponent(sValue.substring(1, sValue.length - 1));
+        }
+        return sValue;
+      };
+      const aKeyValues = sSemanticPath.substring(sSemanticPath.indexOf("(") + 1, sSemanticPath.length - 1).split(",");
+      let aFilters;
+      if (aSemanticKeys.length != aKeyValues.length) {
+        return null;
+      }
+      const bFilteringCaseSensitive = ModelHelper.isFilteringCaseSensitive(oMetaModel);
+      if (aSemanticKeys.length === 1) {
+        // Take the first key value
+        const sKeyValue = fnUnquoteAndDecode(aKeyValues[0]);
+        aFilters = [new Filter({
+          path: aSemanticKeys[0].$PropertyPath,
+          operator: FilterOperator.EQ,
+          value1: sKeyValue,
+          caseSensitive: bFilteringCaseSensitive
+        })];
+      } else {
+        const mKeyValues = {};
+        // Create a map of all key values
+        aKeyValues.forEach(function (sKeyAssignment) {
+          const aParts = sKeyAssignment.split("="),
+            sKeyValue = fnUnquoteAndDecode(aParts[1]);
+          mKeyValues[aParts[0]] = sKeyValue;
+        });
+        let bFailed = false;
+        aFilters = aSemanticKeys.map(function (oSemanticKey) {
+          const sKey = oSemanticKey.$PropertyPath,
+            sValue = mKeyValues[sKey];
+          if (sValue !== undefined) {
+            return new Filter({
+              path: sKey,
+              operator: FilterOperator.EQ,
+              value1: sValue,
+              caseSensitive: bFilteringCaseSensitive
+            });
+          } else {
+            bFailed = true;
+            return new Filter({
+              path: "XX"
+            }); // will be ignore anyway since we return after
+          }
+        });
+
+        if (bFailed) {
+          return null;
+        }
+      }
+
+      // Add a draft filter to make sure we take the draft entity if there is one
+      // Or the active entity otherwise
+      const oDraftFilter = new Filter({
+        filters: [new Filter("IsActiveEntity", "EQ", false), new Filter("SiblingEntity/IsActiveEntity", "EQ", null)],
+        and: false
+      });
+      aFilters.push(oDraftFilter);
+      return new Filter(aFilters, true);
+    }
+
+    /**
+     * Converts a path with semantic keys to a path with technical keys.
+     *
+     * @param sSemanticPath The path with semantic keys
+     * @param oModel The model for the path
+     * @param aSemanticKeys The semantic keys for the path
+     * @returns A Promise containing the path with technical keys if sSemanticPath could be interpreted as a semantic path, null otherwise
+     * @ui5-restricted
+     */;
+    _proto._getTechnicalPathFromSemanticPath = function _getTechnicalPathFromSemanticPath(sSemanticPath, oModel, aSemanticKeys) {
+      var _sEntitySetPath;
+      const oMetaModel = oModel.getMetaModel();
+      let sEntitySetPath = oMetaModel.getMetaContext(sSemanticPath).getPath();
+      if (!aSemanticKeys || aSemanticKeys.length === 0) {
+        // No semantic keys
+        return Promise.resolve(null);
+      }
+
+      // Create a set of filters corresponding to all keys
+      const oFilter = this._createFilterFromSemanticPath(sSemanticPath, aSemanticKeys, oMetaModel);
+      if (oFilter === null) {
+        // Couldn't interpret the path as a semantic one
+        return Promise.resolve(null);
+      }
+
+      // Load the corresponding object
+      if (!((_sEntitySetPath = sEntitySetPath) !== null && _sEntitySetPath !== void 0 && _sEntitySetPath.startsWith("/"))) {
+        sEntitySetPath = `/${sEntitySetPath}`;
+      }
+      const oListBinding = oModel.bindList(sEntitySetPath, undefined, undefined, oFilter, {
+        $$groupId: "$auto.Heroes"
+      });
+      return oListBinding.requestContexts(0, 2).then(function (oContexts) {
+        if (oContexts && oContexts.length) {
+          return oContexts[0].getPath();
+        } else {
+          // No data could be loaded
+          return null;
+        }
+      });
+    }
+
+    /**
+     * Checks if a path is eligible for semantic bookmarking.
+     *
+     * @param sPath The path to test
+     * @param oMetaModel The associated metadata model
+     * @returns `true` if the path is eligible
+     * @ui5-restricted
+     */;
+    _proto._checkPathForSemanticBookmarking = function _checkPathForSemanticBookmarking(sPath, oMetaModel) {
+      // Only path on root objects allow semantic bookmarking, i.e. sPath = xxx(yyy)
+      const aMatches = /^[\/]?(\w+)\([^\/]+\)$/.exec(sPath);
+      if (!aMatches) {
+        return false;
+      }
+      // Get the entitySet name
+      const sEntitySetPath = `/${aMatches[1]}`;
+      // Check the entity set supports draft (otherwise we don't support semantic bookmarking)
+      const oDraftRoot = oMetaModel.getObject(`${sEntitySetPath}@com.sap.vocabularies.Common.v1.DraftRoot`);
+      const oDraftNode = oMetaModel.getObject(`${sEntitySetPath}@com.sap.vocabularies.Common.v1.DraftNode`);
+      return oDraftRoot || oDraftNode ? true : false;
+    }
+
+    /**
+     * Builds a path with semantic keys from a path with technical keys.
+     *
+     * @param sPathToResolve The path to be transformed
+     * @param oModel The OData model
+     * @returns String promise for the new path. If sPathToResolved couldn't be interpreted as a semantic path, it is returned as is.
+     * @ui5-restricted
+     */;
+    _proto._resolveSemanticPath = function _resolveSemanticPath(sPathToResolve, oModel) {
+      const oMetaModel = oModel.getMetaModel();
+      const oLastSemanticMapping = this._oRoutingService.getLastSemanticMapping();
+      let sCurrentHashNoParams = this._oRouter.getHashChanger().getHash().split("?")[0];
+      if (sCurrentHashNoParams && sCurrentHashNoParams.lastIndexOf("/") === sCurrentHashNoParams.length - 1) {
+        // Remove trailing '/'
+        sCurrentHashNoParams = sCurrentHashNoParams.substring(0, sCurrentHashNoParams.length - 1);
+      }
+      let sRootEntityName = sCurrentHashNoParams && sCurrentHashNoParams.substr(0, sCurrentHashNoParams.indexOf("("));
+      if (sRootEntityName.indexOf("/") === 0) {
+        sRootEntityName = sRootEntityName.substring(1);
+      }
+      const bAllowSemanticBookmark = this._checkPathForSemanticBookmarking(sCurrentHashNoParams, oMetaModel),
+        aSemanticKeys = bAllowSemanticBookmark && SemanticKeyHelper.getSemanticKeys(oMetaModel, sRootEntityName);
+      if (!aSemanticKeys) {
+        // No semantic keys available --> use the path as is
+        return Promise.resolve(sPathToResolve);
+      } else if (oLastSemanticMapping && oLastSemanticMapping.semanticPath === sPathToResolve) {
+        // This semantic path has been resolved previously
+        return Promise.resolve(oLastSemanticMapping.technicalPath);
+      } else {
+        // We need resolve the semantic path to get the technical keys
+        return this._getTechnicalPathFromSemanticPath(sCurrentHashNoParams, oModel, aSemanticKeys).then(sTechnicalPath => {
+          if (sTechnicalPath && sTechnicalPath !== sPathToResolve) {
+            // The semantic path was resolved (otherwise keep the original value for target)
+            this._oRoutingService.setLastSemanticMapping({
+              technicalPath: sTechnicalPath,
+              semanticPath: sPathToResolve
+            });
+            return sTechnicalPath;
+          } else {
+            return sPathToResolve;
+          }
+        });
+      }
+    }
+
+    /**
+     * Sets the binding context of the page from a path.
+     *
+     * @param sTargetPath The path to build the context. Needs to contain technical keys only.
+     * @param oModel The OData model
+     * @param oNavigationParameters Navigation parameters
+     * @ui5-restricted
+     */;
+    _proto._bindPageToPath = function _bindPageToPath(sTargetPath, oModel, oNavigationParameters) {
+      const oCurrentContext = this._getBindingContext(),
+        sCurrentPath = oCurrentContext && oCurrentContext.getPath(),
+        oUseContext = oNavigationParameters.useContext;
+
+      // We set the binding context only if it's different from the current one
+      // or if we have a context already selected
+      if (oUseContext && oUseContext.getPath() === sTargetPath) {
+        if (oUseContext !== oCurrentContext) {
+          // We already have the context to be used, and it's not the current one
+          const oRootViewController = this._oAppComponent.getRootViewController();
+
+          // In case of FCL, if we're reusing a context from a table (through navigation), we refresh it to avoid outdated data
+          // We don't wait for the refresh to be completed (requestRefresh), so that the corresponding query goes into the same
+          // batch as the ones from controls in the page.
+          if (oRootViewController.isFclEnabled() && oNavigationParameters.reason === NavigationReason.RowPress) {
+            const metaModel = oUseContext.getModel().getMetaModel();
+            if (!oUseContext.getBinding().hasPendingChanges()) {
+              oUseContext.refresh();
+            } else if (isConnected(this.getView()) || ModelHelper.isDraftSupported(metaModel, oUseContext.getPath()) && ModelHelper.isCollaborationDraftSupported(metaModel)) {
+              // If there are pending changes but we're in collaboration draft, we force the refresh (discarding pending changes) as we need to have the latest version.
+              // When navigating from LR to OP, the view is not connected yet --> check if we're in draft with collaboration from the metamodel
+              oUseContext.getBinding().resetChanges();
+              oUseContext.refresh();
+            }
+          }
+          this._bindPageToContext(oUseContext, oModel, oNavigationParameters);
+        }
+      } else if (sCurrentPath !== sTargetPath) {
+        // We need to create a new context for its path
+        this._bindPageToContext(this._createContext(sTargetPath, oModel), oModel, oNavigationParameters);
+      } else if (oNavigationParameters.reason !== NavigationReason.AppStateChanged && EditState.isEditStateDirty()) {
+        this._refreshBindingContext(oCurrentContext);
+      }
+    }
+
+    /**
+     * Binds the page to a context.
+     *
+     * @param oContext Context to be bound
+     * @param oModel The OData model
+     * @param oNavigationParameters Navigation parameters
+     * @ui5-restricted
+     */;
+    _proto._bindPageToContext = function _bindPageToContext(oContext, oModel, oNavigationParameters) {
+      if (!oContext) {
+        this.onBeforeBinding(null);
+        this.onAfterBinding(null);
+        return;
+      }
+      const oParentListBinding = oContext.getBinding();
+      const oRootViewController = this._oAppComponent.getRootViewController();
+      if (oRootViewController.isFclEnabled()) {
+        if (!oParentListBinding || !oParentListBinding.isA("sap.ui.model.odata.v4.ODataListBinding")) {
+          // if the parentBinding is not a listBinding, we create a new context
+          oContext = this._createContext(oContext.getPath(), oModel);
+        }
+        try {
+          this._setKeepAlive(oContext, true, () => {
+            if (oRootViewController.isContextUsedInPages(oContext)) {
+              this.navigateBackFromContext(oContext);
+            }
+          }, true // Load messages, otherwise they don't get refreshed later, e.g. for side effects
+          );
+        } catch (oError) {
+          // setKeepAlive throws an exception if the parent listbinding doesn't have $$ownRequest=true
+          // This case for custom fragments is supported, but an error is logged to make the lack of synchronization apparent
+          Log.error(`View for ${oContext.getPath()} won't be synchronized. Parent listBinding must have binding parameter $$ownRequest=true`);
+        }
+      } else if (!oParentListBinding || oParentListBinding.isA("sap.ui.model.odata.v4.ODataListBinding")) {
+        // We need to recreate the context otherwise we get errors
+        oContext = this._createContext(oContext.getPath(), oModel);
+      }
+
+      // Set the binding context with the proper before/after callbacks
+      this.onBeforeBinding(oContext, {
+        editable: oNavigationParameters.bTargetEditable,
+        listBinding: oParentListBinding,
+        bPersistOPScroll: oNavigationParameters.bPersistOPScroll,
+        bDraftNavigation: oNavigationParameters.bDraftNavigation,
+        showPlaceholder: oNavigationParameters.bShowPlaceholder
+      });
+      this._setBindingContext(oContext);
+      this.onAfterBinding(oContext);
+    }
+
+    /**
+     * Creates a context from a path.
+     *
+     * @param sPath The path
+     * @param oModel The OData model
+     * @returns The created context
+     * @ui5-restricted
+     */;
+    _proto._createContext = function _createContext(sPath, oModel) {
+      const oPageComponent = this._oPageComponent,
+        sEntitySet = oPageComponent && oPageComponent.getEntitySet && oPageComponent.getEntitySet(),
+        sContextPath = oPageComponent && oPageComponent.getContextPath && oPageComponent.getContextPath() || sEntitySet && `/${sEntitySet}`,
+        oMetaModel = oModel.getMetaModel(),
+        mParameters = {
+          $$groupId: "$auto.Heroes",
+          $$updateGroupId: "$auto",
+          $$patchWithoutSideEffects: true
+        };
+      // In case of draft: $select the state flags (HasActiveEntity, HasDraftEntity, and IsActiveEntity)
+      const oDraftRoot = oMetaModel.getObject(`${sContextPath}@com.sap.vocabularies.Common.v1.DraftRoot`);
+      const oDraftNode = oMetaModel.getObject(`${sContextPath}@com.sap.vocabularies.Common.v1.DraftNode`);
+      const oRootViewController = this._oAppComponent.getRootViewController();
+      if (oRootViewController.isFclEnabled()) {
+        const oContext = this._getKeepAliveContext(oModel, sPath, false, mParameters);
+        if (!oContext) {
+          throw new Error(`Cannot create keepAlive context ${sPath}`);
+        } else if (oDraftRoot || oDraftNode) {
+          if (oContext.getProperty("IsActiveEntity") === undefined) {
+            oContext.requestProperty(["HasActiveEntity", "HasDraftEntity", "IsActiveEntity"]);
+            if (oDraftRoot) {
+              oContext.requestObject("DraftAdministrativeData");
+            }
+          } else {
+            // when switching between draft and edit we need to ensure those properties are requested again even if they are in the binding's cache
+            // otherwise when you edit and go to the saved version you have no way of switching back to the edit version
+            oContext.requestSideEffects(oDraftRoot ? ["HasActiveEntity", "HasDraftEntity", "IsActiveEntity", "DraftAdministrativeData"] : ["HasActiveEntity", "HasDraftEntity", "IsActiveEntity"]);
+          }
+        }
+        return oContext;
+      } else {
+        if (sEntitySet) {
+          const sMessagesPath = oMetaModel.getObject(`${sContextPath}/@com.sap.vocabularies.Common.v1.Messages/$Path`);
+          if (sMessagesPath) {
+            mParameters.$select = sMessagesPath;
+          }
+        }
+
+        // In case of draft: $select the state flags (HasActiveEntity, HasDraftEntity, and IsActiveEntity)
+        if (oDraftRoot || oDraftNode) {
+          if (mParameters.$select === undefined) {
+            mParameters.$select = "HasActiveEntity,HasDraftEntity,IsActiveEntity";
+          } else {
+            mParameters.$select += ",HasActiveEntity,HasDraftEntity,IsActiveEntity";
+          }
+        }
+        if (this._oView.getBindingContext()) {
+          var _this$_oView$getBindi2;
+          const oPreviousBinding = (_this$_oView$getBindi2 = this._oView.getBindingContext()) === null || _this$_oView$getBindi2 === void 0 ? void 0 : _this$_oView$getBindi2.getBinding();
+          oPreviousBinding === null || oPreviousBinding === void 0 ? void 0 : oPreviousBinding.resetChanges().then(() => {
+            oPreviousBinding.destroy();
+          }).catch(oError => {
+            Log.error("Error while reseting the changes to the binding", oError);
+          });
+        }
+        const oHiddenBinding = oModel.bindContext(sPath, undefined, mParameters);
+        oHiddenBinding.attachEventOnce("dataRequested", () => {
+          BusyLocker.lock(this._oView);
+        });
+        oHiddenBinding.attachEventOnce("dataReceived", this.onDataReceived.bind(this));
+        return oHiddenBinding.getBoundContext();
+      }
+    };
+    _proto.onDataReceived = async function onDataReceived(oEvent) {
+      const sErrorDescription = oEvent && oEvent.getParameter("error");
+      if (BusyLocker.isLocked(this._oView)) {
+        BusyLocker.unlock(this._oView);
+      }
+      if (sErrorDescription) {
+        // TODO: in case of 404 the text shall be different
+        try {
+          const oResourceBundle = await Core.getLibraryResourceBundle("sap.fe.core", true);
+          const messageHandler = this.base.messageHandler;
+          let mParams = {};
+          if (sErrorDescription.status === 503) {
+            mParams = {
+              isInitialLoad503Error: true,
+              shellBack: true
+            };
+          } else if (sErrorDescription.status === 400) {
+            mParams = {
+              title: oResourceBundle.getText("C_COMMON_SAPFE_ERROR"),
+              description: oResourceBundle.getText("C_COMMON_SAPFE_DATA_RECEIVED_ERROR_DESCRIPTION"),
+              isDataReceivedError: true,
+              shellBack: true
+            };
+          } else {
+            mParams = {
+              title: oResourceBundle.getText("C_COMMON_SAPFE_ERROR"),
+              description: sErrorDescription,
+              isDataReceivedError: true,
+              shellBack: true
+            };
+          }
+          await messageHandler.showMessages(mParams);
+        } catch (oError) {
+          Log.error("Error while getting the core resource bundle", oError);
+        }
+      }
+    }
+
+    /**
+     * Requests side effects on a binding context to "refresh" it.
+     * TODO: get rid of this once provided by the model
+     * a refresh on the binding context does not work in case a creation row with a transient context is
+     * used. also a requestSideEffects with an empty path would fail due to the transient context
+     * therefore we get all dependent bindings (via private model method) to determine all paths and then
+     * request them.
+     *
+     * @param oBindingContext Context to be refreshed
+     * @ui5-restricted
+     */;
+    _proto._refreshBindingContext = function _refreshBindingContext(oBindingContext) {
+      const oPageComponent = this._oPageComponent;
+      const oSideEffectsService = this._oAppComponent.getSideEffectsService();
+      const sRootContextPath = oBindingContext.getPath();
+      const sEntitySet = oPageComponent && oPageComponent.getEntitySet && oPageComponent.getEntitySet();
+      const sContextPath = oPageComponent && oPageComponent.getContextPath && oPageComponent.getContextPath() || sEntitySet && `/${sEntitySet}`;
+      const oMetaModel = this._oView.getModel().getMetaModel();
+      let sMessagesPath;
+      const aNavigationPropertyPaths = [];
+      const aPropertyPaths = [];
+      const oSideEffects = {
+        TargetProperties: [],
+        TargetEntities: []
+      };
+      function getBindingPaths(oBinding) {
+        let aDependentBindings;
+        const sRelativePath = (oBinding.getContext() && oBinding.getContext().getPath() || "").replace(sRootContextPath, ""); // If no context, this is an absolute binding so no relative path
+        const sPath = (sRelativePath ? `${sRelativePath.slice(1)}/` : sRelativePath) + oBinding.getPath();
+        if (oBinding.isA("sap.ui.model.odata.v4.ODataContextBinding")) {
+          // if (sPath === "") {
+          // now get the dependent bindings
+          aDependentBindings = oBinding.getDependentBindings();
+          if (aDependentBindings) {
+            // ask the dependent bindings (and only those with the specified groupId
+            //if (aDependentBindings.length > 0) {
+            for (let i = 0; i < aDependentBindings.length; i++) {
+              getBindingPaths(aDependentBindings[i]);
+            }
+          } else if (aNavigationPropertyPaths.indexOf(sPath) === -1) {
+            aNavigationPropertyPaths.push(sPath);
+          }
+        } else if (oBinding.isA("sap.ui.model.odata.v4.ODataListBinding")) {
+          if (aNavigationPropertyPaths.indexOf(sPath) === -1) {
+            aNavigationPropertyPaths.push(sPath);
+          }
+        } else if (oBinding.isA("sap.ui.model.odata.v4.ODataPropertyBinding")) {
+          if (aPropertyPaths.indexOf(sPath) === -1) {
+            aPropertyPaths.push(sPath);
+          }
+        }
+      }
+      if (sContextPath) {
+        sMessagesPath = oMetaModel.getObject(`${sContextPath}/@com.sap.vocabularies.Common.v1.Messages/$Path`);
+      }
+
+      // binding of the context must have $$PatchWithoutSideEffects true, this bound context may be needed to be fetched from the dependent binding
+      getBindingPaths(oBindingContext.getBinding());
+      let i;
+      for (i = 0; i < aNavigationPropertyPaths.length; i++) {
+        oSideEffects.TargetEntities.push({
+          $NavigationPropertyPath: aNavigationPropertyPaths[i]
+        });
+      }
+      oSideEffects.TargetProperties = aPropertyPaths;
+      if (sMessagesPath) {
+        oSideEffects.TargetProperties.push(sMessagesPath);
+      }
+      //all this logic to be replaced with a SideEffects request for an empty path (refresh everything), after testing transient contexts
+      oSideEffects.TargetProperties = oSideEffects.TargetProperties.map(sTargetProperty => {
+        if (sTargetProperty) {
+          const index = sTargetProperty.indexOf("/");
+          if (index > 0) {
+            // only request the navigation path and not the property paths further
+            return sTargetProperty.slice(0, index);
+          }
+          return sTargetProperty;
+        }
+      });
+      // OData model will take care of duplicates
+      oSideEffectsService.requestSideEffects(oSideEffects.TargetEntities.concat(oSideEffects.TargetProperties), oBindingContext);
+    }
+
+    /**
+     * Gets the binding context of the page or the component.
+     *
+     * @returns The binding context
+     * @ui5-restricted
+     */;
+    _proto._getBindingContext = function _getBindingContext() {
+      if (this._oPageComponent) {
+        return this._oPageComponent.getBindingContext();
+      } else {
+        return this._oView.getBindingContext();
+      }
+    }
+
+    /**
+     * Sets the binding context of the page or the component.
+     *
+     * @param oContext The binding context
+     * @ui5-restricted
+     */;
+    _proto._setBindingContext = function _setBindingContext(oContext) {
+      var _oPreviousContext;
+      let oPreviousContext, oTargetControl;
+      if (this._oPageComponent) {
+        oPreviousContext = this._oPageComponent.getBindingContext();
+        oTargetControl = this._oPageComponent;
+      } else {
+        oPreviousContext = this._oView.getBindingContext();
+        oTargetControl = this._oView;
+      }
+      oTargetControl.setBindingContext(oContext);
+      if ((_oPreviousContext = oPreviousContext) !== null && _oPreviousContext !== void 0 && _oPreviousContext.isKeepAlive() && oPreviousContext !== oContext) {
+        this._setKeepAlive(oPreviousContext, false);
+      }
+    }
+
+    /**
+     * Gets the flexible column layout (FCL) level corresponding to the view (-1 if the app is not FCL).
+     *
+     * @returns The level
+     * @ui5-restricted
+     */;
+    _proto._getFCLLevel = function _getFCLLevel() {
+      return this._oTargetInformation.FCLLevel;
+    };
+    _proto._setKeepAlive = function _setKeepAlive(oContext, bKeepAlive, fnBeforeDestroy, bRequestMessages) {
+      if (oContext.getPath().endsWith(")")) {
+        // We keep the context alive only if they're part of a collection, i.e. if the path ends with a ')'
+        const oMetaModel = oContext.getModel().getMetaModel();
+        const sMetaPath = oMetaModel.getMetaPath(oContext.getPath());
+        const sMessagesPath = oMetaModel.getObject(`${sMetaPath}/@com.sap.vocabularies.Common.v1.Messages/$Path`);
+        oContext.setKeepAlive(bKeepAlive, fnBeforeDestroy, !!sMessagesPath && bRequestMessages);
+      }
+    };
+    _proto._getKeepAliveContext = function _getKeepAliveContext(oModel, path, bRequestMessages, parameters) {
+      // Get the path for the context that is really kept alive (part of a collection)
+      // i.e. remove all segments not ending with a ')'
+      const keptAliveSegments = path.split("/");
+      const additionnalSegments = [];
+      while (keptAliveSegments.length && !keptAliveSegments[keptAliveSegments.length - 1].endsWith(")")) {
+        additionnalSegments.push(keptAliveSegments.pop());
+      }
+      if (keptAliveSegments.length === 0) {
+        return undefined;
+      }
+      const keptAlivePath = keptAliveSegments.join("/");
+      const oKeepAliveContext = oModel.getKeepAliveContext(keptAlivePath, bRequestMessages, parameters);
+      if (additionnalSegments.length === 0) {
+        return oKeepAliveContext;
+      } else {
+        additionnalSegments.reverse();
+        const additionnalPath = additionnalSegments.join("/");
+        return oModel.bindContext(additionnalPath, oKeepAliveContext).getBoundContext();
+      }
+    }
+
+    /**
+     * Switches between column and full-screen mode when FCL is used.
+     *
+     * @ui5-restricted
+     */;
+    _proto.switchFullScreen = function switchFullScreen() {
+      const oSource = this.base.getView();
+      const oFCLHelperModel = oSource.getModel("fclhelper"),
+        bIsFullScreen = oFCLHelperModel.getProperty("/actionButtonsInfo/isFullScreen"),
+        sNextLayout = oFCLHelperModel.getProperty(bIsFullScreen ? "/actionButtonsInfo/exitFullScreen" : "/actionButtonsInfo/fullScreen"),
+        oRootViewController = this._oAppComponent.getRootViewController();
+      const oContext = oRootViewController.getRightmostContext ? oRootViewController.getRightmostContext() : oSource.getBindingContext();
+      this.base._routing.navigateToContext(oContext, {
+        sLayout: sNextLayout
+      }).catch(function () {
+        Log.warning("cannot switch between column and fullscreen");
+      });
+    }
+
+    /**
+     * Closes the column for the current view in a FCL.
+     *
+     * @ui5-restricted
+     */;
+    _proto.closeColumn = function closeColumn() {
+      const oViewData = this._oView.getViewData();
+      const oContext = this._oView.getBindingContext();
+      const oMetaModel = oContext.getModel().getMetaModel();
+      const navigationParameters = {
+        noPreservationCache: true,
+        sLayout: this._oView.getModel("fclhelper").getProperty("/actionButtonsInfo/closeColumn")
+      };
+      if ((oViewData === null || oViewData === void 0 ? void 0 : oViewData.viewLevel) === 1 && ModelHelper.isDraftSupported(oMetaModel, oContext.getPath())) {
+        draft.processDataLossOrDraftDiscardConfirmation(() => {
+          this.navigateBackFromContext(oContext, navigationParameters);
+        }, Function.prototype, oContext, this._oView.getController(), false, draft.NavigationType.BackNavigation);
+      } else {
+        this.navigateBackFromContext(oContext, navigationParameters);
+      }
+    };
+    return InternalRouting;
+  }(ControllerExtension), (_applyDecoratedDescriptor(_class2.prototype, "onExit", [_dec2], Object.getOwnPropertyDescriptor(_class2.prototype, "onExit"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onInit", [_dec3], Object.getOwnPropertyDescriptor(_class2.prototype, "onInit"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onRouteMatched", [_dec4, _dec5], Object.getOwnPropertyDescriptor(_class2.prototype, "onRouteMatched"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onRouteMatchedFinished", [_dec6, _dec7], Object.getOwnPropertyDescriptor(_class2.prototype, "onRouteMatchedFinished"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onBeforeBinding", [_dec8, _dec9], Object.getOwnPropertyDescriptor(_class2.prototype, "onBeforeBinding"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onAfterBinding", [_dec10, _dec11], Object.getOwnPropertyDescriptor(_class2.prototype, "onAfterBinding"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "navigateToTarget", [_dec12], Object.getOwnPropertyDescriptor(_class2.prototype, "navigateToTarget"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "navigateToRoute", [_dec13], Object.getOwnPropertyDescriptor(_class2.prototype, "navigateToRoute"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "navigateToContext", [_dec14, _dec15], Object.getOwnPropertyDescriptor(_class2.prototype, "navigateToContext"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "navigateBackFromContext", [_dec16, _dec17], Object.getOwnPropertyDescriptor(_class2.prototype, "navigateBackFromContext"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "navigateForwardToContext", [_dec18, _dec19], Object.getOwnPropertyDescriptor(_class2.prototype, "navigateForwardToContext"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "navigateBackFromTransientState", [_dec20, _dec21], Object.getOwnPropertyDescriptor(_class2.prototype, "navigateBackFromTransientState"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "navigateToMessagePage", [_dec22, _dec23], Object.getOwnPropertyDescriptor(_class2.prototype, "navigateToMessagePage"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "isCurrentStateImpactedBy", [_dec24, _dec25], Object.getOwnPropertyDescriptor(_class2.prototype, "isCurrentStateImpactedBy"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onDataReceived", [_dec26], Object.getOwnPropertyDescriptor(_class2.prototype, "onDataReceived"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "switchFullScreen", [_dec27, _dec28], Object.getOwnPropertyDescriptor(_class2.prototype, "switchFullScreen"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "closeColumn", [_dec29, _dec30], Object.getOwnPropertyDescriptor(_class2.prototype, "closeColumn"), _class2.prototype)), _class2)) || _class);
+  return InternalRouting;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["InternalRouting","defineUI5Class","methodOverride","publicExtension","extensible","OverrideExecution","After","finalExtension","Before","onExit","_oRoutingService","detachRouteMatched","_fnRouteMatchedBound","onInit","_oView","base","getView","_oAppComponent","CommonUtils","getAppComponent","_oPageComponent","Component","getOwnerComponentFor","_oRouter","getRouter","_oRouterProxy","getRouterProxy","Error","getService","then","oRoutingService","_onRouteMatched","bind","attachRouteMatched","_oTargetInformation","getTargetInformationFor","catch","onRouteMatched","onRouteMatchedFinished","onBeforeBinding","oBindingContext","mParameters","oRouting","getController","routing","onAfterBinding","getRootViewController","onContextBoundToView","navigateToTarget","oContext","sNavigationTargetName","bPreserveHistory","oNavigationConfiguration","getNavigationConfiguration","oDetailRoute","detail","sRouteName","route","mParameterMapping","parameters","navigateTo","getViewData","navigateToRoute","sTargetRouteName","oParameters","navigateToContext","oContextInfo","isA","asyncContext","activateRouteMatchSynchronization","checkNoHashChange","editable","bPersistOPScroll","updateFCLLevel","bForceFocus","oError","Log","error","bDeferredContext","callExtension","oInternalModel","getModel","setProperty","sourceBindingContext","getObject","bindingContext","oEvent","bOverrideNav","onBeforeNavigation","Promise","resolve","FCLLevel","_getFCLLevel","navigateBackFromContext","navigateForwardToContext","getBindingContext","getProperty","navigateBackFromTransientState","sHash","getHash","indexOf","navBack","navigateToMessagePage","sErrorMessage","navToHash","getDefaultCreateHash","displayErrorPage","isCurrentStateImpactedBy","_isViewPartOfRoute","routeInformation","aTargets","targets","targetName","viewLevel","routeLevel","_setBindingContext","_buildBindingPath","routeArguments","bindingPattern","navigationParameters","path","replace","deferred","sKey","sValue","bTargetEditable","hasOwnProperty","bActionCreate","getParameter","getBindingContextPattern","contextPattern","undefined","mArguments","getParameters","arguments","oNavigationParameters","oModel","oOut","_bindDeferred","_bindPage","finally","updateUIStateForView","sTargetPath","oAsyncContext","createDeferredContext","useContext","currentBindingContext","_getBindingContext","hasPendingChanges","getBinding","resetChanges","_bindPageToContext","_resolveSemanticPath","sTechnicalPath","_bindPageToPath","oResourceBundle","Core","getLibraryResourceBundle","getText","title","description","message","_createFilterFromSemanticPath","sSemanticPath","aSemanticKeys","oMetaModel","fnUnquoteAndDecode","lastIndexOf","length","decodeURIComponent","substring","aKeyValues","split","aFilters","bFilteringCaseSensitive","ModelHelper","isFilteringCaseSensitive","sKeyValue","Filter","$PropertyPath","operator","FilterOperator","EQ","value1","caseSensitive","mKeyValues","forEach","sKeyAssignment","aParts","bFailed","map","oSemanticKey","oDraftFilter","filters","and","push","_getTechnicalPathFromSemanticPath","getMetaModel","sEntitySetPath","getMetaContext","getPath","oFilter","startsWith","oListBinding","bindList","$$groupId","requestContexts","oContexts","_checkPathForSemanticBookmarking","sPath","aMatches","exec","oDraftRoot","oDraftNode","sPathToResolve","oLastSemanticMapping","getLastSemanticMapping","sCurrentHashNoParams","getHashChanger","sRootEntityName","substr","bAllowSemanticBookmark","SemanticKeyHelper","getSemanticKeys","semanticPath","technicalPath","setLastSemanticMapping","oCurrentContext","sCurrentPath","oUseContext","oRootViewController","isFclEnabled","reason","NavigationReason","RowPress","metaModel","refresh","isConnected","isDraftSupported","isCollaborationDraftSupported","_createContext","AppStateChanged","EditState","isEditStateDirty","_refreshBindingContext","oParentListBinding","_setKeepAlive","isContextUsedInPages","listBinding","bDraftNavigation","showPlaceholder","bShowPlaceholder","oPageComponent","sEntitySet","getEntitySet","sContextPath","getContextPath","$$updateGroupId","$$patchWithoutSideEffects","_getKeepAliveContext","requestProperty","requestObject","requestSideEffects","sMessagesPath","$select","oPreviousBinding","destroy","oHiddenBinding","bindContext","attachEventOnce","BusyLocker","lock","onDataReceived","getBoundContext","sErrorDescription","isLocked","unlock","messageHandler","mParams","status","isInitialLoad503Error","shellBack","isDataReceivedError","showMessages","oSideEffectsService","getSideEffectsService","sRootContextPath","aNavigationPropertyPaths","aPropertyPaths","oSideEffects","TargetProperties","TargetEntities","getBindingPaths","oBinding","aDependentBindings","sRelativePath","getContext","slice","getDependentBindings","i","$NavigationPropertyPath","sTargetProperty","index","concat","oPreviousContext","oTargetControl","setBindingContext","isKeepAlive","bKeepAlive","fnBeforeDestroy","bRequestMessages","endsWith","sMetaPath","getMetaPath","setKeepAlive","keptAliveSegments","additionnalSegments","pop","keptAlivePath","join","oKeepAliveContext","getKeepAliveContext","reverse","additionnalPath","switchFullScreen","oSource","oFCLHelperModel","bIsFullScreen","sNextLayout","getRightmostContext","_routing","sLayout","warning","closeColumn","oViewData","noPreservationCache","draft","processDataLossOrDraftDiscardConfirmation","Function","prototype","NavigationType","BackNavigation","ControllerExtension"],"sourceRoot":".","sources":["InternalRouting.ts"],"sourcesContent":["import Log from \"sap/base/Log\";\nimport type AppComponent from \"sap/fe/core/AppComponent\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport BusyLocker from \"sap/fe/core/controllerextensions/BusyLocker\";\nimport { isConnected } from \"sap/fe/core/controllerextensions/collaboration/ActivitySync\";\nimport draft from \"sap/fe/core/controllerextensions/editFlow/draft\";\nimport NavigationReason from \"sap/fe/core/controllerextensions/routing/NavigationReason\";\nimport type RouterProxy from \"sap/fe/core/controllerextensions/routing/RouterProxy\";\nimport type { EnhanceWithUI5 } from \"sap/fe/core/helpers/ClassSupport\";\nimport { defineUI5Class, extensible, finalExtension, methodOverride, publicExtension } from \"sap/fe/core/helpers/ClassSupport\";\nimport EditState from \"sap/fe/core/helpers/EditState\";\nimport ModelHelper from \"sap/fe/core/helpers/ModelHelper\";\nimport SemanticKeyHelper from \"sap/fe/core/helpers/SemanticKeyHelper\";\nimport type PageController from \"sap/fe/core/PageController\";\nimport type { RoutingService } from \"sap/fe/core/services/RoutingServiceFactory\";\nimport type TemplateComponent from \"sap/fe/core/TemplateComponent\";\nimport type Event from \"sap/ui/base/Event\";\nimport Component from \"sap/ui/core/Component\";\nimport Core from \"sap/ui/core/Core\";\nimport ControllerExtension from \"sap/ui/core/mvc/ControllerExtension\";\nimport OverrideExecution from \"sap/ui/core/mvc/OverrideExecution\";\nimport type View from \"sap/ui/core/mvc/View\";\nimport type Router from \"sap/ui/core/routing/Router\";\nimport Filter from \"sap/ui/model/Filter\";\nimport FilterOperator from \"sap/ui/model/FilterOperator\";\nimport type JSONModel from \"sap/ui/model/json/JSONModel\";\nimport type Context from \"sap/ui/model/odata/v4/Context\";\nimport ODataMetaModel from \"sap/ui/model/odata/v4/ODataMetaModel\";\nimport type ODataModel from \"sap/ui/model/odata/v4/ODataModel\";\n\n/**\n * {@link sap.ui.core.mvc.ControllerExtension Controller extension}\n *\n * @namespace\n * @alias sap.fe.core.controllerextensions.InternalRouting\n * @private\n * @since 1.74.0\n */\n@defineUI5Class(\"sap.fe.core.controllerextensions.InternalRouting\")\nclass InternalRouting extends ControllerExtension {\n\tprivate base!: PageController;\n\tprivate _oView!: View;\n\tprivate _oAppComponent!: AppComponent;\n\tprivate _oPageComponent!: EnhanceWithUI5<TemplateComponent> | null;\n\tprivate _oRouter!: Router;\n\tprivate _oRoutingService!: RoutingService;\n\tprivate _oRouterProxy!: RouterProxy;\n\tprivate _fnRouteMatchedBound!: Function;\n\tprotected _oTargetInformation: any;\n\n\t@methodOverride()\n\tonExit() {\n\t\tif (this._oRoutingService) {\n\t\t\tthis._oRoutingService.detachRouteMatched(this._fnRouteMatchedBound);\n\t\t}\n\t}\n\n\t@methodOverride()\n\tonInit() {\n\t\tthis._oView = this.base.getView();\n\t\tthis._oAppComponent = CommonUtils.getAppComponent(this._oView);\n\t\tthis._oPageComponent = Component.getOwnerComponentFor(this._oView) as EnhanceWithUI5<TemplateComponent>;\n\t\tthis._oRouter = this._oAppComponent.getRouter();\n\t\tthis._oRouterProxy = (this._oAppComponent as any).getRouterProxy();\n\n\t\tif (!this._oAppComponent || !this._oPageComponent) {\n\t\t\tthrow new Error(\"Failed to initialize controler extension 'sap.fe.core.controllerextesions.InternalRouting\");\n\t\t}\n\n\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t// @ts-ignore\n\t\tif (this._oAppComponent === this._oPageComponent) {\n\t\t\t// The view isn't hosted in a dedicated UIComponent, but directly in the app\n\t\t\t// --> just keep the view\n\t\t\tthis._oPageComponent = null;\n\t\t}\n\n\t\tthis._oAppComponent\n\t\t\t.getService(\"routingService\")\n\t\t\t.then((oRoutingService: RoutingService) => {\n\t\t\t\tthis._oRoutingService = oRoutingService;\n\t\t\t\tthis._fnRouteMatchedBound = this._onRouteMatched.bind(this);\n\t\t\t\tthis._oRoutingService.attachRouteMatched(this._fnRouteMatchedBound);\n\t\t\t\tthis._oTargetInformation = oRoutingService.getTargetInformationFor(this._oPageComponent || this._oView);\n\t\t\t})\n\t\t\t.catch(function () {\n\t\t\t\tthrow new Error(\"This controller extension cannot work without a 'routingService' on the main AppComponent\");\n\t\t\t});\n\t}\n\n\t/**\n\t * Triggered every time this controller is a navigation target.\n\t */\n\t@publicExtension()\n\t@extensible(OverrideExecution.After)\n\tonRouteMatched() {\n\t\t/**/\n\t}\n\n\t@publicExtension()\n\t@extensible(OverrideExecution.After)\n\tonRouteMatchedFinished() {\n\t\t/**/\n\t}\n\n\t@publicExtension()\n\t@extensible(OverrideExecution.After)\n\tonBeforeBinding(oBindingContext: any, mParameters?: any) {\n\t\tconst oRouting = (this.base.getView().getController() as any).routing;\n\t\tif (oRouting && oRouting.onBeforeBinding) {\n\t\t\toRouting.onBeforeBinding(oBindingContext, mParameters);\n\t\t}\n\t}\n\n\t@publicExtension()\n\t@extensible(OverrideExecution.After)\n\tonAfterBinding(oBindingContext: any, mParameters?: any) {\n\t\t(this._oAppComponent as any).getRootViewController().onContextBoundToView(oBindingContext);\n\t\tconst oRouting = (this.base.getView().getController() as any).routing;\n\t\tif (oRouting && oRouting.onAfterBinding) {\n\t\t\toRouting.onAfterBinding(oBindingContext, mParameters);\n\t\t}\n\t}\n\n\t///////////////////////////////////////////////////////////\n\t// Methods triggering a navigation after a user action\n\t// (e.g. click on a table row, button, etc...)\n\t///////////////////////////////////////////////////////////\n\n\t/**\n\t * Navigates to the specified navigation target.\n\t *\n\t * @param oContext Context instance\n\t * @param sNavigationTargetName Name of the navigation target\n\t * @param bPreserveHistory True to force the new URL to be added at the end of the browser history (no replace)\n\t * @ui5-restricted\n\t */\n\t@publicExtension()\n\tnavigateToTarget(oContext: any, sNavigationTargetName: string, bPreserveHistory?: boolean) {\n\t\tconst oNavigationConfiguration =\n\t\t\tthis._oPageComponent &&\n\t\t\tthis._oPageComponent.getNavigationConfiguration &&\n\t\t\tthis._oPageComponent.getNavigationConfiguration(sNavigationTargetName);\n\t\tif (oNavigationConfiguration) {\n\t\t\tconst oDetailRoute = oNavigationConfiguration.detail;\n\t\t\tconst sRouteName = oDetailRoute.route;\n\t\t\tconst mParameterMapping = oDetailRoute.parameters;\n\t\t\tthis._oRoutingService.navigateTo(oContext, sRouteName, mParameterMapping, bPreserveHistory);\n\t\t} else {\n\t\t\tthis._oRoutingService.navigateTo(oContext, null, null, bPreserveHistory);\n\t\t}\n\t\tthis._oView.getViewData();\n\t}\n\n\t/**\n\t * Navigates to the specified navigation target route.\n\t *\n\t * @param sTargetRouteName Name of the target route\n\t * @param [oParameters] Parameters to be used with route to create the target hash\n\t * @returns Promise that is resolved when the navigation is finalized\n\t * @ui5-restricted\n\t */\n\t@publicExtension()\n\tnavigateToRoute(sTargetRouteName: string, oParameters?: object) {\n\t\treturn this._oRoutingService.navigateToRoute(sTargetRouteName, oParameters);\n\t}\n\n\t/**\n\t * Navigates to a specific context.\n\t *\n\t * @param oContext The context to be navigated to\n\t * @param [mParameters] Optional navigation parameters\n\t * @returns Promise resolved when the navigation has been triggered\n\t * @ui5-restricted\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tnavigateToContext(oContext: any, mParameters?: any): Promise<boolean> {\n\t\tconst oContextInfo: any = {};\n\t\tmParameters = mParameters || {};\n\n\t\tif (oContext.isA(\"sap.ui.model.odata.v4.ODataListBinding\")) {\n\t\t\tif (mParameters.asyncContext) {\n\t\t\t\t// the context is either created async (Promise)\n\t\t\t\t// We need to activate the routeMatchSynchro on the RouterProxy to avoid that\n\t\t\t\t// the subsequent call to navigateToContext conflicts with the current one\n\t\t\t\tthis._oRouterProxy.activateRouteMatchSynchronization();\n\n\t\t\t\tmParameters.asyncContext\n\t\t\t\t\t.then((asyncContext: any) => {\n\t\t\t\t\t\t// once the context is returned we navigate into it\n\t\t\t\t\t\tthis.navigateToContext(asyncContext, {\n\t\t\t\t\t\t\tcheckNoHashChange: mParameters.checkNoHashChange,\n\t\t\t\t\t\t\teditable: mParameters.editable,\n\t\t\t\t\t\t\tbPersistOPScroll: mParameters.bPersistOPScroll,\n\t\t\t\t\t\t\tupdateFCLLevel: mParameters.updateFCLLevel,\n\t\t\t\t\t\t\tbForceFocus: mParameters.bForceFocus\n\t\t\t\t\t\t});\n\t\t\t\t\t})\n\t\t\t\t\t.catch(function (oError: any) {\n\t\t\t\t\t\tLog.error(\"Error with the async context\", oError);\n\t\t\t\t\t});\n\t\t\t} else if (!mParameters.bDeferredContext) {\n\t\t\t\t// Navigate to a list binding not yet supported\n\t\t\t\tthrow \"navigation to a list binding is not yet supported\";\n\t\t\t}\n\t\t}\n\n\t\tif (mParameters.callExtension) {\n\t\t\tconst oInternalModel = this._oView.getModel(\"internal\") as JSONModel;\n\t\t\toInternalModel.setProperty(\"/paginatorCurrentContext\", null);\n\n\t\t\toContextInfo.sourceBindingContext = oContext.getObject();\n\t\t\toContextInfo.bindingContext = oContext;\n\t\t\tif (mParameters.oEvent) {\n\t\t\t\toContextInfo.oEvent = mParameters.oEvent;\n\t\t\t}\n\t\t\t// Storing the selected context to use it in internal route navigation if neccessary.\n\t\t\tconst bOverrideNav = (this.base.getView().getController() as any).routing.onBeforeNavigation(oContextInfo);\n\t\t\tif (bOverrideNav) {\n\t\t\t\toInternalModel.setProperty(\"/paginatorCurrentContext\", oContext);\n\t\t\t\treturn Promise.resolve(true);\n\t\t\t}\n\t\t}\n\t\tmParameters.FCLLevel = this._getFCLLevel();\n\n\t\treturn this._oRoutingService.navigateToContext(oContext, mParameters, this._oView.getViewData(), this._oTargetInformation);\n\t}\n\n\t/**\n\t * Navigates backwards from a context.\n\t *\n\t * @param oContext Context to be navigated from\n\t * @param [mParameters] Optional navigation parameters\n\t * @returns Promise resolved when the navigation has been triggered\n\t * @ui5-restricted\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tnavigateBackFromContext(oContext: any, mParameters?: any) {\n\t\tmParameters = mParameters || {};\n\t\tmParameters.updateFCLLevel = -1;\n\n\t\treturn this.navigateToContext(oContext, mParameters);\n\t}\n\n\t/**\n\t * Navigates forwards to a context.\n\t *\n\t * @param oContext Context to be navigated to\n\t * @param mParameters Optional navigation parameters\n\t * @returns Promise resolved when the navigation has been triggered\n\t * @ui5-restricted\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tnavigateForwardToContext(oContext: any, mParameters?: any): Promise<boolean> {\n\t\tif (this._oView.getBindingContext(\"internal\")?.getProperty(\"messageFooterContainsErrors\") === true) {\n\t\t\treturn Promise.resolve(true);\n\t\t}\n\t\tmParameters = mParameters || {};\n\t\tmParameters.updateFCLLevel = 1;\n\n\t\treturn this.navigateToContext(oContext, mParameters);\n\t}\n\n\t/**\n\t * Navigates back in history if the current hash corresponds to a transient state.\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tnavigateBackFromTransientState() {\n\t\tconst sHash = this._oRouterProxy.getHash();\n\n\t\t// if triggered while navigating to (...), we need to navigate back\n\t\tif (sHash.indexOf(\"(...)\") !== -1) {\n\t\t\tthis._oRouterProxy.navBack();\n\t\t}\n\t}\n\n\t@publicExtension()\n\t@finalExtension()\n\tnavigateToMessagePage(sErrorMessage: any, mParameters: any) {\n\t\tmParameters = mParameters || {};\n\t\tif (\n\t\t\tthis._oRouterProxy.getHash().indexOf(\"i-action=create\") > -1 ||\n\t\t\tthis._oRouterProxy.getHash().indexOf(\"i-action=autoCreate\") > -1\n\t\t) {\n\t\t\treturn this._oRouterProxy.navToHash(this._oRoutingService.getDefaultCreateHash());\n\t\t} else {\n\t\t\tmParameters.FCLLevel = this._getFCLLevel();\n\n\t\t\treturn (this._oAppComponent as any).getRootViewController().displayErrorPage(sErrorMessage, mParameters);\n\t\t}\n\t}\n\n\t/**\n\t * Checks if one of the current views on the screen is bound to a given context.\n\t *\n\t * @param oContext\n\t * @returns `true` if the state is impacted by the context\n\t * @ui5-restricted\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tisCurrentStateImpactedBy(oContext: any) {\n\t\treturn this._oRoutingService.isCurrentStateImpactedBy(oContext);\n\t}\n\n\t_isViewPartOfRoute(routeInformation: any): boolean {\n\t\tconst aTargets = routeInformation?.targets;\n\t\tif (!aTargets || aTargets.indexOf(this._oTargetInformation.targetName) === -1) {\n\t\t\t// If the target for this view has a view level greater than the route level, it means this view comes \"after\" the route\n\t\t\t// in terms of navigation.\n\t\t\t// In such case, we remove its binding context, to avoid this view to have data if we navigate to it later on\n\t\t\tif ((this._oTargetInformation.viewLevel ?? 0) >= (routeInformation?.routeLevel ?? 0)) {\n\t\t\t\tthis._setBindingContext(null); // This also call setKeepAlive(false) on the current context\n\t\t\t}\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t}\n\n\t_buildBindingPath(routeArguments: any, bindingPattern: string, navigationParameters: any): { path: string; deferred: boolean } {\n\t\tlet path = bindingPattern.replace(\":?query:\", \"\");\n\t\tlet deferred = false;\n\n\t\tfor (const sKey in routeArguments) {\n\t\t\tconst sValue = routeArguments[sKey];\n\t\t\tif (sValue === \"...\" && bindingPattern.indexOf(`{${sKey}}`) >= 0) {\n\t\t\t\tdeferred = true;\n\t\t\t\t// Sometimes in preferredMode = create, the edit button is shown in background when the\n\t\t\t\t// action parameter dialog shows up, setting bTargetEditable passes editable as true\n\t\t\t\t// to onBeforeBinding in _bindTargetPage function\n\t\t\t\tnavigationParameters.bTargetEditable = true;\n\t\t\t}\n\t\t\tpath = path.replace(`{${sKey}}`, sValue);\n\t\t}\n\t\tif (routeArguments[\"?query\"] && routeArguments[\"?query\"].hasOwnProperty(\"i-action\")) {\n\t\t\tnavigationParameters.bActionCreate = true;\n\t\t}\n\n\t\t// the binding path is always absolute\n\t\tif (path && path[0] !== \"/\") {\n\t\t\tpath = `/${path}`;\n\t\t}\n\n\t\treturn { path, deferred };\n\t}\n\n\t///////////////////////////////////////////////////////////\n\t// Methods to bind the page when a route is matched\n\t///////////////////////////////////////////////////////////\n\n\t/**\n\t * Called when a route is matched.\n\t * Builds the binding context from the navigation parameters, and bind the page accordingly.\n\t *\n\t * @param oEvent\n\t * @ui5-restricted\n\t */\n\t_onRouteMatched(oEvent: Event) {\n\t\t// Check if the target for this view is part of the event targets (i.e. is a target for the current route).\n\t\t// If not, we don't need to bind it --> return\n\t\tif (!this._isViewPartOfRoute(oEvent.getParameter(\"routeInformation\"))) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Retrieve the binding context pattern\n\t\tlet bindingPattern;\n\t\tif (this._oPageComponent && this._oPageComponent.getBindingContextPattern) {\n\t\t\tbindingPattern = this._oPageComponent.getBindingContextPattern();\n\t\t}\n\t\tbindingPattern = bindingPattern || this._oTargetInformation.contextPattern;\n\n\t\tif (bindingPattern === null || bindingPattern === undefined) {\n\t\t\t// Don't do this if we already got sTarget == '', which is a valid target pattern\n\t\t\tbindingPattern = oEvent.getParameter(\"routePattern\");\n\t\t}\n\n\t\t// Replace the parameters by their values in the binding context pattern\n\t\tconst mArguments = (oEvent.getParameters() as any).arguments;\n\t\tconst oNavigationParameters = oEvent.getParameter(\"navigationInfo\");\n\t\tconst { path, deferred } = this._buildBindingPath(mArguments, bindingPattern, oNavigationParameters);\n\n\t\tthis.onRouteMatched();\n\n\t\tconst oModel = this._oView.getModel() as ODataModel;\n\t\tlet oOut;\n\t\tif (deferred) {\n\t\t\toOut = this._bindDeferred(path, oNavigationParameters);\n\t\t} else {\n\t\t\toOut = this._bindPage(path, oModel, oNavigationParameters);\n\t\t}\n\t\t// eslint-disable-next-line promise/catch-or-return\n\t\toOut.finally(() => {\n\t\t\tthis.onRouteMatchedFinished();\n\t\t});\n\n\t\t(this._oAppComponent as any).getRootViewController().updateUIStateForView(this._oView, this._getFCLLevel());\n\t}\n\n\t/**\n\t * Deferred binding (during object creation).\n\t *\n\t * @param sTargetPath The path to the deffered context\n\t * @param oNavigationParameters Navigation parameters\n\t * @returns A Promise\n\t * @ui5-restricted\n\t */\n\t_bindDeferred(sTargetPath: string, oNavigationParameters: any) {\n\t\tthis.onBeforeBinding(null, { editable: oNavigationParameters.bTargetEditable });\n\n\t\tif (oNavigationParameters.bDeferredContext || !oNavigationParameters.oAsyncContext) {\n\t\t\t// either the context shall be created in the target page (deferred Context) or it shall\n\t\t\t// be created async but the user refreshed the page / bookmarked this URL\n\t\t\t// TODO: currently the target component creates this document but we shall move this to\n\t\t\t// a central place\n\t\t\tif (this._oPageComponent && this._oPageComponent.createDeferredContext) {\n\t\t\t\tthis._oPageComponent.createDeferredContext(\n\t\t\t\t\tsTargetPath,\n\t\t\t\t\toNavigationParameters.useContext,\n\t\t\t\t\toNavigationParameters.bActionCreate\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\n\t\tconst currentBindingContext = this._getBindingContext();\n\t\tif (currentBindingContext?.hasPendingChanges()) {\n\t\t\t// For now remove the pending changes to avoid the model raises errors and the object page is at least bound\n\t\t\t// Ideally the user should be asked for\n\t\t\tcurrentBindingContext.getBinding().resetChanges();\n\t\t}\n\n\t\t// remove the context to avoid showing old data\n\t\tthis._setBindingContext(null);\n\n\t\tthis.onAfterBinding(null);\n\t\treturn Promise.resolve();\n\t}\n\n\t/**\n\t * Sets the binding context of the page from a path.\n\t *\n\t * @param sTargetPath The path to the context\n\t * @param oModel The OData model\n\t * @param oNavigationParameters Navigation parameters\n\t * @returns A Promise resolved once the binding has been set on the page\n\t * @ui5-restricted\n\t */\n\t_bindPage(sTargetPath: string, oModel: ODataModel, oNavigationParameters: object) {\n\t\tif (sTargetPath === \"\") {\n\t\t\treturn Promise.resolve(this._bindPageToContext(null, oModel, oNavigationParameters));\n\t\t} else {\n\t\t\treturn this._resolveSemanticPath(sTargetPath, oModel)\n\t\t\t\t.then((sTechnicalPath: any) => {\n\t\t\t\t\tthis._bindPageToPath(sTechnicalPath, oModel, oNavigationParameters);\n\t\t\t\t})\n\t\t\t\t.catch((oError: any) => {\n\t\t\t\t\t// Error handling for erroneous metadata request\n\t\t\t\t\tconst oResourceBundle = Core.getLibraryResourceBundle(\"sap.fe.core\");\n\n\t\t\t\t\tthis.navigateToMessagePage(oResourceBundle.getText(\"C_COMMON_SAPFE_DATA_RECEIVED_ERROR\"), {\n\t\t\t\t\t\ttitle: oResourceBundle.getText(\"C_COMMON_SAPFE_ERROR\"),\n\t\t\t\t\t\tdescription: oError.message\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Creates the filter to retrieve a context corresponding to a semantic path.\n\t *\n\t * @param sSemanticPath The semantic path\n\t * @param aSemanticKeys The semantic keys for the path\n\t * @param oMetaModel The instance of the meta model\n\t * @returns The filter\n\t * @ui5-restricted\n\t */\n\t_createFilterFromSemanticPath(sSemanticPath: string, aSemanticKeys: any[], oMetaModel: object) {\n\t\tconst fnUnquoteAndDecode = function (sValue: any) {\n\t\t\tif (sValue.indexOf(\"'\") === 0 && sValue.lastIndexOf(\"'\") === sValue.length - 1) {\n\t\t\t\t// Remove the quotes from the value and decode special chars\n\t\t\t\tsValue = decodeURIComponent(sValue.substring(1, sValue.length - 1));\n\t\t\t}\n\t\t\treturn sValue;\n\t\t};\n\t\tconst aKeyValues = sSemanticPath.substring(sSemanticPath.indexOf(\"(\") + 1, sSemanticPath.length - 1).split(\",\");\n\t\tlet aFilters: Filter[];\n\n\t\tif (aSemanticKeys.length != aKeyValues.length) {\n\t\t\treturn null;\n\t\t}\n\n\t\tconst bFilteringCaseSensitive = ModelHelper.isFilteringCaseSensitive(oMetaModel);\n\n\t\tif (aSemanticKeys.length === 1) {\n\t\t\t// Take the first key value\n\t\t\tconst sKeyValue = fnUnquoteAndDecode(aKeyValues[0]);\n\t\t\taFilters = [\n\t\t\t\tnew Filter({\n\t\t\t\t\tpath: aSemanticKeys[0].$PropertyPath,\n\t\t\t\t\toperator: FilterOperator.EQ,\n\t\t\t\t\tvalue1: sKeyValue,\n\t\t\t\t\tcaseSensitive: bFilteringCaseSensitive\n\t\t\t\t})\n\t\t\t];\n\t\t} else {\n\t\t\tconst mKeyValues: any = {};\n\t\t\t// Create a map of all key values\n\t\t\taKeyValues.forEach(function (sKeyAssignment: string) {\n\t\t\t\tconst aParts = sKeyAssignment.split(\"=\"),\n\t\t\t\t\tsKeyValue = fnUnquoteAndDecode(aParts[1]);\n\n\t\t\t\tmKeyValues[aParts[0]] = sKeyValue;\n\t\t\t});\n\n\t\t\tlet bFailed = false;\n\t\t\taFilters = aSemanticKeys.map(function (oSemanticKey: any) {\n\t\t\t\tconst sKey = oSemanticKey.$PropertyPath,\n\t\t\t\t\tsValue = mKeyValues[sKey];\n\n\t\t\t\tif (sValue !== undefined) {\n\t\t\t\t\treturn new Filter({\n\t\t\t\t\t\tpath: sKey,\n\t\t\t\t\t\toperator: FilterOperator.EQ,\n\t\t\t\t\t\tvalue1: sValue,\n\t\t\t\t\t\tcaseSensitive: bFilteringCaseSensitive\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tbFailed = true;\n\t\t\t\t\treturn new Filter({\n\t\t\t\t\t\tpath: \"XX\"\n\t\t\t\t\t}); // will be ignore anyway since we return after\n\t\t\t\t}\n\t\t\t});\n\n\t\t\tif (bFailed) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t}\n\n\t\t// Add a draft filter to make sure we take the draft entity if there is one\n\t\t// Or the active entity otherwise\n\t\tconst oDraftFilter = new Filter({\n\t\t\tfilters: [new Filter(\"IsActiveEntity\", \"EQ\", false), new Filter(\"SiblingEntity/IsActiveEntity\", \"EQ\", null)],\n\t\t\tand: false\n\t\t});\n\t\taFilters.push(oDraftFilter);\n\n\t\treturn new Filter(aFilters, true);\n\t}\n\n\t/**\n\t * Converts a path with semantic keys to a path with technical keys.\n\t *\n\t * @param sSemanticPath The path with semantic keys\n\t * @param oModel The model for the path\n\t * @param aSemanticKeys The semantic keys for the path\n\t * @returns A Promise containing the path with technical keys if sSemanticPath could be interpreted as a semantic path, null otherwise\n\t * @ui5-restricted\n\t */\n\t_getTechnicalPathFromSemanticPath(sSemanticPath: string, oModel: any, aSemanticKeys: any[]) {\n\t\tconst oMetaModel = oModel.getMetaModel();\n\t\tlet sEntitySetPath = oMetaModel.getMetaContext(sSemanticPath).getPath();\n\n\t\tif (!aSemanticKeys || aSemanticKeys.length === 0) {\n\t\t\t// No semantic keys\n\t\t\treturn Promise.resolve(null);\n\t\t}\n\n\t\t// Create a set of filters corresponding to all keys\n\t\tconst oFilter = this._createFilterFromSemanticPath(sSemanticPath, aSemanticKeys, oMetaModel);\n\t\tif (oFilter === null) {\n\t\t\t// Couldn't interpret the path as a semantic one\n\t\t\treturn Promise.resolve(null);\n\t\t}\n\n\t\t// Load the corresponding object\n\t\tif (!sEntitySetPath?.startsWith(\"/\")) {\n\t\t\tsEntitySetPath = `/${sEntitySetPath}`;\n\t\t}\n\t\tconst oListBinding = oModel.bindList(sEntitySetPath, undefined, undefined, oFilter, {\n\t\t\t$$groupId: \"$auto.Heroes\"\n\t\t});\n\n\t\treturn oListBinding.requestContexts(0, 2).then(function (oContexts: any) {\n\t\t\tif (oContexts && oContexts.length) {\n\t\t\t\treturn oContexts[0].getPath();\n\t\t\t} else {\n\t\t\t\t// No data could be loaded\n\t\t\t\treturn null;\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * Checks if a path is eligible for semantic bookmarking.\n\t *\n\t * @param sPath The path to test\n\t * @param oMetaModel The associated metadata model\n\t * @returns `true` if the path is eligible\n\t * @ui5-restricted\n\t */\n\t_checkPathForSemanticBookmarking(sPath: string, oMetaModel: any) {\n\t\t// Only path on root objects allow semantic bookmarking, i.e. sPath = xxx(yyy)\n\t\tconst aMatches = /^[\\/]?(\\w+)\\([^\\/]+\\)$/.exec(sPath);\n\t\tif (!aMatches) {\n\t\t\treturn false;\n\t\t}\n\t\t// Get the entitySet name\n\t\tconst sEntitySetPath = `/${aMatches[1]}`;\n\t\t// Check the entity set supports draft (otherwise we don't support semantic bookmarking)\n\t\tconst oDraftRoot = oMetaModel.getObject(`${sEntitySetPath}@com.sap.vocabularies.Common.v1.DraftRoot`);\n\t\tconst oDraftNode = oMetaModel.getObject(`${sEntitySetPath}@com.sap.vocabularies.Common.v1.DraftNode`);\n\t\treturn oDraftRoot || oDraftNode ? true : false;\n\t}\n\n\t/**\n\t * Builds a path with semantic keys from a path with technical keys.\n\t *\n\t * @param sPathToResolve The path to be transformed\n\t * @param oModel The OData model\n\t * @returns String promise for the new path. If sPathToResolved couldn't be interpreted as a semantic path, it is returned as is.\n\t * @ui5-restricted\n\t */\n\t_resolveSemanticPath(sPathToResolve: string, oModel: any): Promise<string> {\n\t\tconst oMetaModel = oModel.getMetaModel();\n\t\tconst oLastSemanticMapping = this._oRoutingService.getLastSemanticMapping();\n\t\tlet sCurrentHashNoParams = this._oRouter.getHashChanger().getHash().split(\"?\")[0];\n\n\t\tif (sCurrentHashNoParams && sCurrentHashNoParams.lastIndexOf(\"/\") === sCurrentHashNoParams.length - 1) {\n\t\t\t// Remove trailing '/'\n\t\t\tsCurrentHashNoParams = sCurrentHashNoParams.substring(0, sCurrentHashNoParams.length - 1);\n\t\t}\n\n\t\tlet sRootEntityName = sCurrentHashNoParams && sCurrentHashNoParams.substr(0, sCurrentHashNoParams.indexOf(\"(\"));\n\t\tif (sRootEntityName.indexOf(\"/\") === 0) {\n\t\t\tsRootEntityName = sRootEntityName.substring(1);\n\t\t}\n\t\tconst bAllowSemanticBookmark = this._checkPathForSemanticBookmarking(sCurrentHashNoParams, oMetaModel),\n\t\t\taSemanticKeys = bAllowSemanticBookmark && SemanticKeyHelper.getSemanticKeys(oMetaModel, sRootEntityName);\n\t\tif (!aSemanticKeys) {\n\t\t\t// No semantic keys available --> use the path as is\n\t\t\treturn Promise.resolve(sPathToResolve);\n\t\t} else if (oLastSemanticMapping && oLastSemanticMapping.semanticPath === sPathToResolve) {\n\t\t\t// This semantic path has been resolved previously\n\t\t\treturn Promise.resolve(oLastSemanticMapping.technicalPath);\n\t\t} else {\n\t\t\t// We need resolve the semantic path to get the technical keys\n\t\t\treturn this._getTechnicalPathFromSemanticPath(sCurrentHashNoParams, oModel, aSemanticKeys).then((sTechnicalPath: any) => {\n\t\t\t\tif (sTechnicalPath && sTechnicalPath !== sPathToResolve) {\n\t\t\t\t\t// The semantic path was resolved (otherwise keep the original value for target)\n\t\t\t\t\tthis._oRoutingService.setLastSemanticMapping({\n\t\t\t\t\t\ttechnicalPath: sTechnicalPath,\n\t\t\t\t\t\tsemanticPath: sPathToResolve\n\t\t\t\t\t});\n\t\t\t\t\treturn sTechnicalPath;\n\t\t\t\t} else {\n\t\t\t\t\treturn sPathToResolve;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Sets the binding context of the page from a path.\n\t *\n\t * @param sTargetPath The path to build the context. Needs to contain technical keys only.\n\t * @param oModel The OData model\n\t * @param oNavigationParameters Navigation parameters\n\t * @ui5-restricted\n\t */\n\t_bindPageToPath(sTargetPath: string, oModel: any, oNavigationParameters: any) {\n\t\tconst oCurrentContext = this._getBindingContext(),\n\t\t\tsCurrentPath = oCurrentContext && oCurrentContext.getPath(),\n\t\t\toUseContext = oNavigationParameters.useContext as Context | undefined | null;\n\n\t\t// We set the binding context only if it's different from the current one\n\t\t// or if we have a context already selected\n\t\tif (oUseContext && oUseContext.getPath() === sTargetPath) {\n\t\t\tif (oUseContext !== oCurrentContext) {\n\t\t\t\t// We already have the context to be used, and it's not the current one\n\t\t\t\tconst oRootViewController = this._oAppComponent.getRootViewController();\n\n\t\t\t\t// In case of FCL, if we're reusing a context from a table (through navigation), we refresh it to avoid outdated data\n\t\t\t\t// We don't wait for the refresh to be completed (requestRefresh), so that the corresponding query goes into the same\n\t\t\t\t// batch as the ones from controls in the page.\n\t\t\t\tif (oRootViewController.isFclEnabled() && oNavigationParameters.reason === NavigationReason.RowPress) {\n\t\t\t\t\tconst metaModel = oUseContext.getModel().getMetaModel();\n\t\t\t\t\tif (!oUseContext.getBinding().hasPendingChanges()) {\n\t\t\t\t\t\toUseContext.refresh();\n\t\t\t\t\t} else if (\n\t\t\t\t\t\tisConnected(this.getView()) ||\n\t\t\t\t\t\t(ModelHelper.isDraftSupported(metaModel, oUseContext.getPath()) &&\n\t\t\t\t\t\t\tModelHelper.isCollaborationDraftSupported(metaModel))\n\t\t\t\t\t) {\n\t\t\t\t\t\t// If there are pending changes but we're in collaboration draft, we force the refresh (discarding pending changes) as we need to have the latest version.\n\t\t\t\t\t\t// When navigating from LR to OP, the view is not connected yet --> check if we're in draft with collaboration from the metamodel\n\t\t\t\t\t\toUseContext.getBinding().resetChanges();\n\t\t\t\t\t\toUseContext.refresh();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tthis._bindPageToContext(oUseContext, oModel, oNavigationParameters);\n\t\t\t}\n\t\t} else if (sCurrentPath !== sTargetPath) {\n\t\t\t// We need to create a new context for its path\n\t\t\tthis._bindPageToContext(this._createContext(sTargetPath, oModel), oModel, oNavigationParameters);\n\t\t} else if (oNavigationParameters.reason !== NavigationReason.AppStateChanged && EditState.isEditStateDirty()) {\n\t\t\tthis._refreshBindingContext(oCurrentContext);\n\t\t}\n\t}\n\n\t/**\n\t * Binds the page to a context.\n\t *\n\t * @param oContext Context to be bound\n\t * @param oModel The OData model\n\t * @param oNavigationParameters Navigation parameters\n\t * @ui5-restricted\n\t */\n\t_bindPageToContext(oContext: Context | null, oModel: ODataModel, oNavigationParameters: any) {\n\t\tif (!oContext) {\n\t\t\tthis.onBeforeBinding(null);\n\t\t\tthis.onAfterBinding(null);\n\t\t\treturn;\n\t\t}\n\n\t\tconst oParentListBinding = oContext.getBinding();\n\t\tconst oRootViewController = (this._oAppComponent as any).getRootViewController();\n\t\tif (oRootViewController.isFclEnabled()) {\n\t\t\tif (!oParentListBinding || !oParentListBinding.isA(\"sap.ui.model.odata.v4.ODataListBinding\")) {\n\t\t\t\t// if the parentBinding is not a listBinding, we create a new context\n\t\t\t\toContext = this._createContext(oContext.getPath(), oModel);\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tthis._setKeepAlive(\n\t\t\t\t\toContext,\n\t\t\t\t\ttrue,\n\t\t\t\t\t() => {\n\t\t\t\t\t\tif (oRootViewController.isContextUsedInPages(oContext)) {\n\t\t\t\t\t\t\tthis.navigateBackFromContext(oContext);\n\t\t\t\t\t\t}\n\t\t\t\t\t},\n\t\t\t\t\ttrue // Load messages, otherwise they don't get refreshed later, e.g. for side effects\n\t\t\t\t);\n\t\t\t} catch (oError) {\n\t\t\t\t// setKeepAlive throws an exception if the parent listbinding doesn't have $$ownRequest=true\n\t\t\t\t// This case for custom fragments is supported, but an error is logged to make the lack of synchronization apparent\n\t\t\t\tLog.error(\n\t\t\t\t\t`View for ${oContext.getPath()} won't be synchronized. Parent listBinding must have binding parameter $$ownRequest=true`\n\t\t\t\t);\n\t\t\t}\n\t\t} else if (!oParentListBinding || oParentListBinding.isA(\"sap.ui.model.odata.v4.ODataListBinding\")) {\n\t\t\t// We need to recreate the context otherwise we get errors\n\t\t\toContext = this._createContext(oContext.getPath(), oModel);\n\t\t}\n\n\t\t// Set the binding context with the proper before/after callbacks\n\t\tthis.onBeforeBinding(oContext, {\n\t\t\teditable: oNavigationParameters.bTargetEditable,\n\t\t\tlistBinding: oParentListBinding,\n\t\t\tbPersistOPScroll: oNavigationParameters.bPersistOPScroll,\n\t\t\tbDraftNavigation: oNavigationParameters.bDraftNavigation,\n\t\t\tshowPlaceholder: oNavigationParameters.bShowPlaceholder\n\t\t});\n\n\t\tthis._setBindingContext(oContext);\n\t\tthis.onAfterBinding(oContext);\n\t}\n\n\t/**\n\t * Creates a context from a path.\n\t *\n\t * @param sPath The path\n\t * @param oModel The OData model\n\t * @returns The created context\n\t * @ui5-restricted\n\t */\n\t_createContext(sPath: string, oModel: ODataModel) {\n\t\tconst oPageComponent = this._oPageComponent,\n\t\t\tsEntitySet = oPageComponent && oPageComponent.getEntitySet && oPageComponent.getEntitySet(),\n\t\t\tsContextPath =\n\t\t\t\t(oPageComponent && oPageComponent.getContextPath && oPageComponent.getContextPath()) || (sEntitySet && `/${sEntitySet}`),\n\t\t\toMetaModel = oModel.getMetaModel(),\n\t\t\tmParameters: any = {\n\t\t\t\t$$groupId: \"$auto.Heroes\",\n\t\t\t\t$$updateGroupId: \"$auto\",\n\t\t\t\t$$patchWithoutSideEffects: true\n\t\t\t};\n\t\t// In case of draft: $select the state flags (HasActiveEntity, HasDraftEntity, and IsActiveEntity)\n\t\tconst oDraftRoot = oMetaModel.getObject(`${sContextPath}@com.sap.vocabularies.Common.v1.DraftRoot`);\n\t\tconst oDraftNode = oMetaModel.getObject(`${sContextPath}@com.sap.vocabularies.Common.v1.DraftNode`);\n\t\tconst oRootViewController = (this._oAppComponent as any).getRootViewController();\n\t\tif (oRootViewController.isFclEnabled()) {\n\t\t\tconst oContext = this._getKeepAliveContext(oModel, sPath, false, mParameters);\n\t\t\tif (!oContext) {\n\t\t\t\tthrow new Error(`Cannot create keepAlive context ${sPath}`);\n\t\t\t} else if (oDraftRoot || oDraftNode) {\n\t\t\t\tif (oContext.getProperty(\"IsActiveEntity\") === undefined) {\n\t\t\t\t\toContext.requestProperty([\"HasActiveEntity\", \"HasDraftEntity\", \"IsActiveEntity\"]);\n\t\t\t\t\tif (oDraftRoot) {\n\t\t\t\t\t\toContext.requestObject(\"DraftAdministrativeData\");\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\t// when switching between draft and edit we need to ensure those properties are requested again even if they are in the binding's cache\n\t\t\t\t\t// otherwise when you edit and go to the saved version you have no way of switching back to the edit version\n\t\t\t\t\toContext.requestSideEffects(\n\t\t\t\t\t\toDraftRoot\n\t\t\t\t\t\t\t? [\"HasActiveEntity\", \"HasDraftEntity\", \"IsActiveEntity\", \"DraftAdministrativeData\"]\n\t\t\t\t\t\t\t: [\"HasActiveEntity\", \"HasDraftEntity\", \"IsActiveEntity\"]\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn oContext;\n\t\t} else {\n\t\t\tif (sEntitySet) {\n\t\t\t\tconst sMessagesPath = oMetaModel.getObject(`${sContextPath}/@com.sap.vocabularies.Common.v1.Messages/$Path`);\n\t\t\t\tif (sMessagesPath) {\n\t\t\t\t\tmParameters.$select = sMessagesPath;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// In case of draft: $select the state flags (HasActiveEntity, HasDraftEntity, and IsActiveEntity)\n\t\t\tif (oDraftRoot || oDraftNode) {\n\t\t\t\tif (mParameters.$select === undefined) {\n\t\t\t\t\tmParameters.$select = \"HasActiveEntity,HasDraftEntity,IsActiveEntity\";\n\t\t\t\t} else {\n\t\t\t\t\tmParameters.$select += \",HasActiveEntity,HasDraftEntity,IsActiveEntity\";\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (this._oView.getBindingContext()) {\n\t\t\t\tconst oPreviousBinding = (this._oView.getBindingContext() as any)?.getBinding();\n\t\t\t\toPreviousBinding\n\t\t\t\t\t?.resetChanges()\n\t\t\t\t\t.then(() => {\n\t\t\t\t\t\toPreviousBinding.destroy();\n\t\t\t\t\t})\n\t\t\t\t\t.catch((oError: any) => {\n\t\t\t\t\t\tLog.error(\"Error while reseting the changes to the binding\", oError);\n\t\t\t\t\t});\n\t\t\t}\n\n\t\t\tconst oHiddenBinding = oModel.bindContext(sPath, undefined, mParameters);\n\n\t\t\toHiddenBinding.attachEventOnce(\"dataRequested\", () => {\n\t\t\t\tBusyLocker.lock(this._oView);\n\t\t\t});\n\t\t\toHiddenBinding.attachEventOnce(\"dataReceived\", this.onDataReceived.bind(this));\n\t\t\treturn oHiddenBinding.getBoundContext();\n\t\t}\n\t}\n\n\t@publicExtension()\n\tasync onDataReceived(oEvent: Event) {\n\t\tconst sErrorDescription = oEvent && oEvent.getParameter(\"error\");\n\t\tif (BusyLocker.isLocked(this._oView)) {\n\t\t\tBusyLocker.unlock(this._oView);\n\t\t}\n\n\t\tif (sErrorDescription) {\n\t\t\t// TODO: in case of 404 the text shall be different\n\t\t\ttry {\n\t\t\t\tconst oResourceBundle = await Core.getLibraryResourceBundle(\"sap.fe.core\", true);\n\t\t\t\tconst messageHandler = this.base.messageHandler;\n\t\t\t\tlet mParams = {};\n\t\t\t\tif (sErrorDescription.status === 503) {\n\t\t\t\t\tmParams = {\n\t\t\t\t\t\tisInitialLoad503Error: true,\n\t\t\t\t\t\tshellBack: true\n\t\t\t\t\t};\n\t\t\t\t} else if (sErrorDescription.status === 400) {\n\t\t\t\t\tmParams = {\n\t\t\t\t\t\ttitle: oResourceBundle.getText(\"C_COMMON_SAPFE_ERROR\"),\n\t\t\t\t\t\tdescription: oResourceBundle.getText(\"C_COMMON_SAPFE_DATA_RECEIVED_ERROR_DESCRIPTION\"),\n\t\t\t\t\t\tisDataReceivedError: true,\n\t\t\t\t\t\tshellBack: true\n\t\t\t\t\t};\n\t\t\t\t} else {\n\t\t\t\t\tmParams = {\n\t\t\t\t\t\ttitle: oResourceBundle.getText(\"C_COMMON_SAPFE_ERROR\"),\n\t\t\t\t\t\tdescription: sErrorDescription,\n\t\t\t\t\t\tisDataReceivedError: true,\n\t\t\t\t\t\tshellBack: true\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t\tawait messageHandler.showMessages(mParams);\n\t\t\t} catch (oError: any) {\n\t\t\t\tLog.error(\"Error while getting the core resource bundle\", oError);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Requests side effects on a binding context to \"refresh\" it.\n\t * TODO: get rid of this once provided by the model\n\t * a refresh on the binding context does not work in case a creation row with a transient context is\n\t * used. also a requestSideEffects with an empty path would fail due to the transient context\n\t * therefore we get all dependent bindings (via private model method) to determine all paths and then\n\t * request them.\n\t *\n\t * @param oBindingContext Context to be refreshed\n\t * @ui5-restricted\n\t */\n\t_refreshBindingContext(oBindingContext: any) {\n\t\tconst oPageComponent = this._oPageComponent;\n\t\tconst oSideEffectsService = this._oAppComponent.getSideEffectsService();\n\t\tconst sRootContextPath = oBindingContext.getPath();\n\t\tconst sEntitySet = oPageComponent && oPageComponent.getEntitySet && oPageComponent.getEntitySet();\n\t\tconst sContextPath =\n\t\t\t(oPageComponent && oPageComponent.getContextPath && oPageComponent.getContextPath()) || (sEntitySet && `/${sEntitySet}`);\n\t\tconst oMetaModel = this._oView.getModel().getMetaModel() as ODataMetaModel;\n\t\tlet sMessagesPath;\n\t\tconst aNavigationPropertyPaths: any[] = [];\n\t\tconst aPropertyPaths: any[] = [];\n\t\tconst oSideEffects: any = {\n\t\t\tTargetProperties: [],\n\t\t\tTargetEntities: []\n\t\t};\n\n\t\tfunction getBindingPaths(oBinding: any) {\n\t\t\tlet aDependentBindings;\n\t\t\tconst sRelativePath = ((oBinding.getContext() && oBinding.getContext().getPath()) || \"\").replace(sRootContextPath, \"\"); // If no context, this is an absolute binding so no relative path\n\t\t\tconst sPath = (sRelativePath ? `${sRelativePath.slice(1)}/` : sRelativePath) + oBinding.getPath();\n\n\t\t\tif (oBinding.isA(\"sap.ui.model.odata.v4.ODataContextBinding\")) {\n\t\t\t\t// if (sPath === \"\") {\n\t\t\t\t// now get the dependent bindings\n\t\t\t\taDependentBindings = oBinding.getDependentBindings();\n\t\t\t\tif (aDependentBindings) {\n\t\t\t\t\t// ask the dependent bindings (and only those with the specified groupId\n\t\t\t\t\t//if (aDependentBindings.length > 0) {\n\t\t\t\t\tfor (let i = 0; i < aDependentBindings.length; i++) {\n\t\t\t\t\t\tgetBindingPaths(aDependentBindings[i]);\n\t\t\t\t\t}\n\t\t\t\t} else if (aNavigationPropertyPaths.indexOf(sPath) === -1) {\n\t\t\t\t\taNavigationPropertyPaths.push(sPath);\n\t\t\t\t}\n\t\t\t} else if (oBinding.isA(\"sap.ui.model.odata.v4.ODataListBinding\")) {\n\t\t\t\tif (aNavigationPropertyPaths.indexOf(sPath) === -1) {\n\t\t\t\t\taNavigationPropertyPaths.push(sPath);\n\t\t\t\t}\n\t\t\t} else if (oBinding.isA(\"sap.ui.model.odata.v4.ODataPropertyBinding\")) {\n\t\t\t\tif (aPropertyPaths.indexOf(sPath) === -1) {\n\t\t\t\t\taPropertyPaths.push(sPath);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (sContextPath) {\n\t\t\tsMessagesPath = oMetaModel.getObject(`${sContextPath}/@com.sap.vocabularies.Common.v1.Messages/$Path`);\n\t\t}\n\n\t\t// binding of the context must have $$PatchWithoutSideEffects true, this bound context may be needed to be fetched from the dependent binding\n\t\tgetBindingPaths(oBindingContext.getBinding());\n\n\t\tlet i;\n\t\tfor (i = 0; i < aNavigationPropertyPaths.length; i++) {\n\t\t\toSideEffects.TargetEntities.push({\n\t\t\t\t$NavigationPropertyPath: aNavigationPropertyPaths[i]\n\t\t\t});\n\t\t}\n\t\toSideEffects.TargetProperties = aPropertyPaths;\n\t\tif (sMessagesPath) {\n\t\t\toSideEffects.TargetProperties.push(sMessagesPath);\n\t\t}\n\t\t//all this logic to be replaced with a SideEffects request for an empty path (refresh everything), after testing transient contexts\n\t\toSideEffects.TargetProperties = oSideEffects.TargetProperties.map((sTargetProperty: String) => {\n\t\t\tif (sTargetProperty) {\n\t\t\t\tconst index = sTargetProperty.indexOf(\"/\");\n\t\t\t\tif (index > 0) {\n\t\t\t\t\t// only request the navigation path and not the property paths further\n\t\t\t\t\treturn sTargetProperty.slice(0, index);\n\t\t\t\t}\n\t\t\t\treturn sTargetProperty;\n\t\t\t}\n\t\t});\n\t\t// OData model will take care of duplicates\n\t\toSideEffectsService.requestSideEffects(oSideEffects.TargetEntities.concat(oSideEffects.TargetProperties), oBindingContext);\n\t}\n\n\t/**\n\t * Gets the binding context of the page or the component.\n\t *\n\t * @returns The binding context\n\t * @ui5-restricted\n\t */\n\t_getBindingContext(): Context | null | undefined {\n\t\tif (this._oPageComponent) {\n\t\t\treturn this._oPageComponent.getBindingContext() as Context;\n\t\t} else {\n\t\t\treturn this._oView.getBindingContext() as Context;\n\t\t}\n\t}\n\n\t/**\n\t * Sets the binding context of the page or the component.\n\t *\n\t * @param oContext The binding context\n\t * @ui5-restricted\n\t */\n\t_setBindingContext(oContext: any) {\n\t\tlet oPreviousContext, oTargetControl;\n\t\tif (this._oPageComponent) {\n\t\t\toPreviousContext = this._oPageComponent.getBindingContext() as Context;\n\t\t\toTargetControl = this._oPageComponent;\n\t\t} else {\n\t\t\toPreviousContext = this._oView.getBindingContext() as Context;\n\t\t\toTargetControl = this._oView;\n\t\t}\n\n\t\toTargetControl.setBindingContext(oContext);\n\n\t\tif (oPreviousContext?.isKeepAlive() && oPreviousContext !== oContext) {\n\t\t\tthis._setKeepAlive(oPreviousContext, false);\n\t\t}\n\t}\n\n\t/**\n\t * Gets the flexible column layout (FCL) level corresponding to the view (-1 if the app is not FCL).\n\t *\n\t * @returns The level\n\t * @ui5-restricted\n\t */\n\t_getFCLLevel() {\n\t\treturn this._oTargetInformation.FCLLevel;\n\t}\n\n\t_setKeepAlive(oContext: Context, bKeepAlive: boolean, fnBeforeDestroy?: Function, bRequestMessages?: boolean) {\n\t\tif (oContext.getPath().endsWith(\")\")) {\n\t\t\t// We keep the context alive only if they're part of a collection, i.e. if the path ends with a ')'\n\t\t\tconst oMetaModel = oContext.getModel().getMetaModel();\n\t\t\tconst sMetaPath = oMetaModel.getMetaPath(oContext.getPath());\n\t\t\tconst sMessagesPath = oMetaModel.getObject(`${sMetaPath}/@com.sap.vocabularies.Common.v1.Messages/$Path`);\n\t\t\toContext.setKeepAlive(bKeepAlive, fnBeforeDestroy, !!sMessagesPath && bRequestMessages);\n\t\t}\n\t}\n\n\t_getKeepAliveContext(oModel: ODataModel, path: string, bRequestMessages?: boolean, parameters?: any): Context | undefined {\n\t\t// Get the path for the context that is really kept alive (part of a collection)\n\t\t// i.e. remove all segments not ending with a ')'\n\t\tconst keptAliveSegments = path.split(\"/\");\n\t\tconst additionnalSegments: string[] = [];\n\t\twhile (keptAliveSegments.length && !keptAliveSegments[keptAliveSegments.length - 1].endsWith(\")\")) {\n\t\t\tadditionnalSegments.push(keptAliveSegments.pop()!);\n\t\t}\n\n\t\tif (keptAliveSegments.length === 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst keptAlivePath = keptAliveSegments.join(\"/\");\n\t\tconst oKeepAliveContext = oModel.getKeepAliveContext(keptAlivePath, bRequestMessages, parameters);\n\n\t\tif (additionnalSegments.length === 0) {\n\t\t\treturn oKeepAliveContext;\n\t\t} else {\n\t\t\tadditionnalSegments.reverse();\n\t\t\tconst additionnalPath = additionnalSegments.join(\"/\");\n\t\t\treturn oModel.bindContext(additionnalPath, oKeepAliveContext).getBoundContext();\n\t\t}\n\t}\n\n\t/**\n\t * Switches between column and full-screen mode when FCL is used.\n\t *\n\t * @ui5-restricted\n\t */\n\n\t@publicExtension()\n\t@finalExtension()\n\tswitchFullScreen() {\n\t\tconst oSource = this.base.getView();\n\t\tconst oFCLHelperModel = oSource.getModel(\"fclhelper\"),\n\t\t\tbIsFullScreen = oFCLHelperModel.getProperty(\"/actionButtonsInfo/isFullScreen\"),\n\t\t\tsNextLayout = oFCLHelperModel.getProperty(\n\t\t\t\tbIsFullScreen ? \"/actionButtonsInfo/exitFullScreen\" : \"/actionButtonsInfo/fullScreen\"\n\t\t\t),\n\t\t\toRootViewController = (this._oAppComponent as any).getRootViewController();\n\n\t\tconst oContext = oRootViewController.getRightmostContext ? oRootViewController.getRightmostContext() : oSource.getBindingContext();\n\n\t\tthis.base._routing.navigateToContext(oContext, { sLayout: sNextLayout }).catch(function () {\n\t\t\tLog.warning(\"cannot switch between column and fullscreen\");\n\t\t});\n\t}\n\n\t/**\n\t * Closes the column for the current view in a FCL.\n\t *\n\t * @ui5-restricted\n\t */\n\t@publicExtension()\n\t@extensible(OverrideExecution.Before)\n\tcloseColumn() {\n\t\tconst oViewData = this._oView.getViewData() as any;\n\t\tconst oContext = this._oView.getBindingContext() as Context;\n\t\tconst oMetaModel = oContext.getModel().getMetaModel();\n\t\tconst navigationParameters = {\n\t\t\tnoPreservationCache: true,\n\t\t\tsLayout: this._oView.getModel(\"fclhelper\").getProperty(\"/actionButtonsInfo/closeColumn\")\n\t\t};\n\n\t\tif (oViewData?.viewLevel === 1 && ModelHelper.isDraftSupported(oMetaModel, oContext.getPath())) {\n\t\t\tdraft.processDataLossOrDraftDiscardConfirmation(\n\t\t\t\t() => {\n\t\t\t\t\tthis.navigateBackFromContext(oContext, navigationParameters);\n\t\t\t\t},\n\t\t\t\tFunction.prototype,\n\t\t\t\toContext,\n\t\t\t\tthis._oView.getController(),\n\t\t\t\tfalse,\n\t\t\t\tdraft.NavigationType.BackNavigation\n\t\t\t);\n\t\t} else {\n\t\t\tthis.navigateBackFromContext(oContext, navigationParameters);\n\t\t}\n\t}\n}\n\nexport default InternalRouting;\n"],"mappings":"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"}