@sapui5/sap.fe.core 1.110.0 → 1.111.0

package/src/sap/fe/core/services/NavigationServiceFactory-dbg.js

@@ -0,0 +1,320 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2023 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/navigation/NavigationHandler", "sap/ui/core/service/Service", "sap/ui/core/service/ServiceFactory"], function (NavigationHandler, Service, ServiceFactory) {
+  "use strict";
+
+  var _exports = {};
+  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); }
+  let NavigationService = /*#__PURE__*/function (_Service) {
+    _inheritsLoose(NavigationService, _Service);
+    function NavigationService() {
+      return _Service.apply(this, arguments) || this;
+    }
+    _exports.NavigationService = NavigationService;
+    var _proto = NavigationService.prototype;
+    _proto.init = function init() {
+      const oContext = this.getContext(),
+        oComponent = oContext && oContext.scopeObject;
+      this.oNavHandler = new NavigationHandler(oComponent);
+      this.oNavHandler.setModel(oComponent.getModel());
+      this.initPromise = Promise.resolve(this);
+    };
+    _proto.exit = function exit() {
+      this.oNavHandler.destroy();
+    }
+
+    /**
+     * Triggers a cross-app navigation after saving the inner and the cross-app states.
+     *
+     * @private
+     * @ui5-restricted
+     * @param sSemanticObject Semantic object of the target app
+     * @param sActionName Action of the target app
+     * @param [vNavigationParameters] Navigation parameters as an object with key/value pairs or as a string representation of
+     *        such an object. If passed as an object, the properties are not checked against the <code>IsPotentialSensitive</code> or
+     *        <code>Measure</code> type.
+     * @param [oInnerAppData] Object for storing current state of the app
+     * @param [fnOnError] Callback that is called if an error occurs during navigation <br>
+     * @param [oExternalAppData] Object for storing the state which will be forwarded to the target component.
+     * @param [sNavMode] Argument is used to overwrite the FLP-configured target for opening a URL. If used, only the
+     *        <code>explace</code> or <code>inplace</code> values are allowed. Any other value will lead to an exception
+     *        <code>NavigationHandler.INVALID_NAV_MODE</code>.
+     */;
+    _proto.navigate = function navigate(sSemanticObject, sActionName, vNavigationParameters, oInnerAppData, fnOnError, oExternalAppData, sNavMode) {
+      // TODO: Navigation Handler does not handle navigation without a context
+      // but in v4 DataFieldForIBN with requiresContext false can trigger a navigation without any context
+      // This should be handled
+      this.oNavHandler.navigate(sSemanticObject, sActionName, vNavigationParameters, oInnerAppData, fnOnError, oExternalAppData, sNavMode);
+    }
+    /**
+     * Parses the incoming URL and returns a Promise.
+     *
+     * @returns A Promise object which returns the
+     * extracted app state, the startup parameters, and the type of navigation when execution is successful,
+     * @private
+     * @ui5-restricted
+     */;
+    _proto.parseNavigation = function parseNavigation() {
+      return this.oNavHandler.parseNavigation();
+    }
+    /**
+     * Processes navigation-related tasks related to beforePopoverOpens event handling for the SmartLink control and returns a Promise object.
+     *
+     * @param oTableEventParameters The parameters made available by the SmartTable control when the SmartLink control has been clicked,
+     *        an instance of a PopOver object
+     * @param sSelectionVariant Stringified JSON object as returned, for example, from getDataSuiteFormat() of the SmartFilterBar control
+     * @param [mInnerAppData] Object containing the current state of the app. If provided, opening the Popover is deferred until the
+     *        inner app data is saved in a consistent way.
+     * @returns A Promise object to monitor when all actions of the function have been executed; if the execution is successful, the
+     *          modified oTableEventParameters is returned; if an error occurs, an error object of type
+     *          {@link sap.fe.navigation.NavError} is returned
+     * @private
+     */;
+    _proto._processBeforeSmartLinkPopoverOpens = function _processBeforeSmartLinkPopoverOpens(oTableEventParameters, sSelectionVariant, mInnerAppData) {
+      return this.oNavHandler.processBeforeSmartLinkPopoverOpens(oTableEventParameters, sSelectionVariant, mInnerAppData);
+    }
+
+    /**
+     * Processes selectionVariant string and returns a Promise object (semanticAttributes and AppStateKey).
+     *
+     * @param sSelectionVariant Stringified JSON object
+     * @returns A Promise object to monitor when all actions of the function have been executed; if the execution is successful, the
+     *          semanticAttributes as well as the appStateKey are returned; if an error occurs, an error object of type
+     *          {@link sap.fe.navigation.NavError} is returned
+     * <br>
+     * @example <code>
+     *
+     * 		var oSelectionVariant = new sap.fe.navigation.SelectionVariant();
+     * 		oSelectionVariant.addSelectOption("CompanyCode", "I", "EQ", "0001");
+     * 		oSelectionVariant.addSelectOption("Customer", "I", "EQ", "C0001");
+     * 		var sSelectionVariant= oSelectionVariant.toJSONString();
+     *
+     * 		var oNavigationHandler = new sap.fe.navigation.NavigationHandler(oController);
+     * 		var oPromiseObject = oNavigationHandler._getAppStateKeyAndUrlParameters(sSelectionVariant);
+     *
+     * 		oPromiseObject.done(function(oSemanticAttributes, sAppStateKey){
+     * 			// here you can add coding that should run after all app state and the semantic attributes have been returned.
+     * 		});
+     *
+     * 		oPromiseObject.fail(function(oError){
+     * 			//some error handling
+     * 		});
+     *
+     * </code>
+     * @private
+     * @ui5-restricted
+     */;
+    _proto.getAppStateKeyAndUrlParameters = function getAppStateKeyAndUrlParameters(sSelectionVariant) {
+      return this.oNavHandler._getAppStateKeyAndUrlParameters(sSelectionVariant);
+    }
+
+    /**
+     * Gets the application specific technical parameters.
+     *
+     * @returns Containing the technical parameters.
+     * @private
+     * @ui5-restricted
+     */;
+    _proto.getTechnicalParameters = function getTechnicalParameters() {
+      return this.oNavHandler.getTechnicalParameters();
+    }
+    /**
+     * Sets the application specific technical parameters. Technical parameters will not be added to the selection variant passed to the
+     * application.
+     * As a default sap-system, sap-ushell-defaultedParameterNames and hcpApplicationId are considered as technical parameters.
+     *
+     * @param aTechnicalParameters List of parameter names to be considered as technical parameters. <code>null</code> or
+     *        <code>undefined</code> may be used to reset the complete list.
+     * @private
+     * @ui5-restricted
+     */;
+    _proto.setTechnicalParameters = function setTechnicalParameters(aTechnicalParameters) {
+      this.oNavHandler.setTechnicalParameters(aTechnicalParameters);
+    }
+    /**
+     * Sets the model that is used for verification of sensitive information. If the model is not set, the unnamed component model is used for the
+     * verification of sensitive information.
+     *
+     * @private
+     * @ui5-restricted
+     * @param oModel Model For checking sensitive information
+     */;
+    _proto.setModel = function setModel(oModel) {
+      this.oNavHandler.setModel(oModel);
+    }
+    /**
+     * Changes the URL according to the current app state and stores the app state for later retrieval.
+     *
+     * @private
+     * @ui5-restricted
+     * @param mInnerAppData Object containing the current state of the app
+     * @param [bImmediateHashReplace=true] If set to false, the inner app hash will not be replaced until storing is successful; do not
+     *        set to false if you cannot react to the resolution of the Promise, for example, when calling the beforeLinkPressed event
+     * @param [bSkipHashReplace=false] If set to true, the inner app hash will not be replaced in the storeInnerAppState. Also the bImmediateHashReplace
+     * 		  will be ignored.
+     * @returns A Promise object to monitor when all the actions of the function have been executed; if the execution is successful, the
+     *          app state key is returned; if an error occurs, an object of type {@link sap.fe.navigation.NavError} is
+     *          returned
+     */;
+    _proto.storeInnerAppStateAsync = function storeInnerAppStateAsync(mInnerAppData, bImmediateHashReplace, bSkipHashReplace) {
+      // safely converting JQuerry deferred to ES6 promise
+      return new Promise((resolve, reject) => this.oNavHandler.storeInnerAppStateAsync(mInnerAppData, bImmediateHashReplace, bSkipHashReplace).then(resolve, reject));
+    }
+    /**
+     * Changes the URL according to the current app state and stores the app state for later retrieval.
+     *
+     * @private
+     * @ui5-restricted
+     * @param mInnerAppData Object containing the current state of the app
+     * @param [bImmediateHashReplace=false] If set to false, the inner app hash will not be replaced until storing is successful; do not
+     * @returns An object containing the appStateId and a promise object to monitor when all the actions of the function have been
+     * executed; Please note that the appStateKey may be undefined or empty.
+     */;
+    _proto.storeInnerAppStateWithImmediateReturn = function storeInnerAppStateWithImmediateReturn(mInnerAppData, bImmediateHashReplace) {
+      return this.oNavHandler.storeInnerAppStateWithImmediateReturn(mInnerAppData, bImmediateHashReplace);
+    }
+    /**
+     * Changes the URL according to the current sAppStateKey. As an reaction route change event will be triggered.
+     *
+     * @private
+     * @ui5-restricted
+     * @param sAppStateKey The new app state key.
+     */;
+    _proto.replaceHash = function replaceHash(sAppStateKey) {
+      this.oNavHandler.replaceHash(sAppStateKey);
+    };
+    _proto.replaceInnerAppStateKey = function replaceInnerAppStateKey(sAppHash, sAppStateKey) {
+      return this.oNavHandler._replaceInnerAppStateKey(sAppHash, sAppStateKey);
+    }
+    /**
+     * Get single values from SelectionVariant for url parameters.
+     *
+     * @private
+     * @ui5-restricted
+     * @param [vSelectionVariant]
+     * @param [vSelectionVariant.oUrlParamaters]
+     * @returns The url parameters
+     */;
+    _proto.getUrlParametersFromSelectionVariant = function getUrlParametersFromSelectionVariant(vSelectionVariant) {
+      return this.oNavHandler._getURLParametersFromSelectionVariant(vSelectionVariant);
+    }
+
+    /**
+     * Save app state and return immediately without waiting for response.
+     *
+     * @private
+     * @ui5-restricted
+     * @param oInSelectionVariant Instance of sap.fe.navigation.SelectionVariant
+     * @returns AppState key
+     */;
+    _proto.saveAppStateWithImmediateReturn = function saveAppStateWithImmediateReturn(oInSelectionVariant) {
+      if (oInSelectionVariant) {
+        const sSelectionVariant = oInSelectionVariant.toJSONString(),
+          // create an SV for app state in string format
+          oSelectionVariant = JSON.parse(sSelectionVariant),
+          // convert string into JSON to store in AppState
+          oXAppStateObject = {
+            selectionVariant: oSelectionVariant
+          },
+          oReturn = this.oNavHandler._saveAppStateWithImmediateReturn(oXAppStateObject);
+        return oReturn !== null && oReturn !== void 0 && oReturn.appStateKey ? oReturn.appStateKey : "";
+      } else {
+        return undefined;
+      }
+    }
+
+    /**
+     * Mix Attributes and selectionVariant.
+     *
+     * @param vSemanticAttributes Object/(Array of Objects) containing key/value pairs
+     * @param sSelectionVariant The selection variant in string format as provided by the SmartFilterBar control
+     * @param [iSuppressionBehavior=sap.fe.navigation.SuppressionBehavior.standard] Indicates whether semantic
+     *        attributes with special values (see {@link sap.fe.navigation.SuppressionBehavior suppression behavior}) must be
+     *        suppressed before they are combined with the selection variant; several
+     *        {@link sap.fe.navigation.SuppressionBehavior suppression behaviors} can be combined with the bitwise OR operator
+     *        (|)
+     * @returns Instance of {@link sap.fe.navigation.SelectionVariant}
+     */;
+    _proto.mixAttributesAndSelectionVariant = function mixAttributesAndSelectionVariant(vSemanticAttributes, sSelectionVariant, iSuppressionBehavior) {
+      return this.oNavHandler.mixAttributesAndSelectionVariant(vSemanticAttributes, sSelectionVariant, iSuppressionBehavior);
+    }
+
+    /**
+     * The method creates a context url based on provided data. This context url can either be used as.
+     *
+     * @param sEntitySetName Used for url determination
+     * @param [oModel] The ODataModel used for url determination. If omitted, the NavigationHandler model is used.
+     * @returns The context url for the given entities
+     */;
+    _proto.constructContextUrl = function constructContextUrl(sEntitySetName, oModel) {
+      return this.oNavHandler.constructContextUrl(sEntitySetName, oModel);
+    };
+    _proto.getInterface = function getInterface() {
+      return this;
+    };
+    return NavigationService;
+  }(Service);
+  _exports.NavigationService = NavigationService;
+  function fnGetEmptyObject() {
+    return {};
+  }
+  function fnGetPromise() {
+    return Promise.resolve({});
+  }
+  function fnGetJQueryPromise() {
+    const oMyDeffered = jQuery.Deferred();
+    oMyDeffered.resolve({}, {}, "initial");
+    return oMyDeffered.promise();
+  }
+  function fnGetEmptyString() {
+    return "";
+  }
+  let NavigationServicesMock = /*#__PURE__*/function () {
+    function NavigationServicesMock() {
+      this.createEmptyAppState = fnGetEmptyObject;
+      this.storeInnerAppStateWithImmediateReturn = fnGetEmptyObject;
+      this.mixAttributesAndSelectionVariant = fnGetEmptyObject;
+      this.getAppState = fnGetPromise;
+      this.getStartupAppState = fnGetPromise;
+      this.parseNavigation = fnGetJQueryPromise;
+      this.constructContextUrl = fnGetEmptyString;
+      this.initPromise = Promise.resolve(this);
+    }
+    _exports.NavigationServicesMock = NavigationServicesMock;
+    var _proto2 = NavigationServicesMock.prototype;
+    _proto2.getInterface = function getInterface() {
+      return this;
+    }
+
+    // return empty object
+    ;
+    _proto2.replaceInnerAppStateKey = function replaceInnerAppStateKey(sAppHash) {
+      return sAppHash ? sAppHash : "";
+    };
+    _proto2.navigate = function navigate() {
+      // Don't do anything
+    };
+    return NavigationServicesMock;
+  }();
+  _exports.NavigationServicesMock = NavigationServicesMock;
+  let NavigationServiceFactory = /*#__PURE__*/function (_ServiceFactory) {
+    _inheritsLoose(NavigationServiceFactory, _ServiceFactory);
+    function NavigationServiceFactory() {
+      return _ServiceFactory.apply(this, arguments) || this;
+    }
+    var _proto3 = NavigationServiceFactory.prototype;
+    _proto3.createInstance = function createInstance(oServiceContext) {
+      const oNavigationService = sap.ushell && sap.ushell.Container ? new NavigationService(oServiceContext) : new NavigationServicesMock();
+      // Wait For init
+      return oNavigationService.initPromise.then(function (oService) {
+        return oService;
+      });
+    };
+    return NavigationServiceFactory;
+  }(ServiceFactory);
+  return NavigationServiceFactory;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["NavigationService","init","oContext","getContext","oComponent","scopeObject","oNavHandler","NavigationHandler","setModel","getModel","initPromise","Promise","resolve","exit","destroy","navigate","sSemanticObject","sActionName","vNavigationParameters","oInnerAppData","fnOnError","oExternalAppData","sNavMode","parseNavigation","_processBeforeSmartLinkPopoverOpens","oTableEventParameters","sSelectionVariant","mInnerAppData","processBeforeSmartLinkPopoverOpens","getAppStateKeyAndUrlParameters","_getAppStateKeyAndUrlParameters","getTechnicalParameters","setTechnicalParameters","aTechnicalParameters","oModel","storeInnerAppStateAsync","bImmediateHashReplace","bSkipHashReplace","reject","then","storeInnerAppStateWithImmediateReturn","replaceHash","sAppStateKey","replaceInnerAppStateKey","sAppHash","_replaceInnerAppStateKey","getUrlParametersFromSelectionVariant","vSelectionVariant","_getURLParametersFromSelectionVariant","saveAppStateWithImmediateReturn","oInSelectionVariant","toJSONString","oSelectionVariant","JSON","parse","oXAppStateObject","selectionVariant","oReturn","_saveAppStateWithImmediateReturn","appStateKey","undefined","mixAttributesAndSelectionVariant","vSemanticAttributes","iSuppressionBehavior","constructContextUrl","sEntitySetName","getInterface","Service","fnGetEmptyObject","fnGetPromise","fnGetJQueryPromise","oMyDeffered","jQuery","Deferred","promise","fnGetEmptyString","NavigationServicesMock","createEmptyAppState","getAppState","getStartupAppState","NavigationServiceFactory","createInstance","oServiceContext","oNavigationService","sap","ushell","Container","oService","ServiceFactory"],"sourceRoot":".","sources":["NavigationServiceFactory.ts"],"sourcesContent":["import type { InnerAppData } from \"sap/fe/navigation/NavigationHandler\";\nimport NavigationHandler from \"sap/fe/navigation/NavigationHandler\";\nimport type SelectionVariant from \"sap/fe/navigation/SelectionVariant\";\nimport type { SerializedSelectionVariant } from \"sap/fe/navigation/SelectionVariant\";\nimport Service from \"sap/ui/core/service/Service\";\nimport ServiceFactory from \"sap/ui/core/service/ServiceFactory\";\nimport type { ServiceContext } from \"types/extension_types\";\n\ntype NavigationServiceSettings = {};\nexport class NavigationService extends Service<NavigationServiceSettings> {\n\tinitPromise!: Promise<any>;\n\toNavHandler!: NavigationHandler;\n\tinit() {\n\t\tconst oContext = this.getContext(),\n\t\t\toComponent = oContext && oContext.scopeObject;\n\n\t\tthis.oNavHandler = new NavigationHandler(oComponent);\n\t\tthis.oNavHandler.setModel(oComponent.getModel());\n\t\tthis.initPromise = Promise.resolve(this);\n\t}\n\texit() {\n\t\tthis.oNavHandler.destroy();\n\t}\n\n\t/**\n\t * Triggers a cross-app navigation after saving the inner and the cross-app states.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param sSemanticObject Semantic object of the target app\n\t * @param sActionName Action of the target app\n\t * @param [vNavigationParameters] Navigation parameters as an object with key/value pairs or as a string representation of\n\t *        such an object. If passed as an object, the properties are not checked against the <code>IsPotentialSensitive</code> or\n\t *        <code>Measure</code> type.\n\t * @param [oInnerAppData] Object for storing current state of the app\n\t * @param [fnOnError] Callback that is called if an error occurs during navigation <br>\n\t * @param [oExternalAppData] Object for storing the state which will be forwarded to the target component.\n\t * @param [sNavMode] Argument is used to overwrite the FLP-configured target for opening a URL. If used, only the\n\t *        <code>explace</code> or <code>inplace</code> values are allowed. Any other value will lead to an exception\n\t *        <code>NavigationHandler.INVALID_NAV_MODE</code>.\n\t */\n\tnavigate(\n\t\tsSemanticObject: string,\n\t\tsActionName: string,\n\t\tvNavigationParameters: string | object,\n\t\toInnerAppData?: InnerAppData,\n\t\tfnOnError?: Function,\n\t\toExternalAppData?: any,\n\t\tsNavMode?: string\n\t) {\n\t\t// TODO: Navigation Handler does not handle navigation without a context\n\t\t// but in v4 DataFieldForIBN with requiresContext false can trigger a navigation without any context\n\t\t// This should be handled\n\t\tthis.oNavHandler.navigate(\n\t\t\tsSemanticObject,\n\t\t\tsActionName,\n\t\t\tvNavigationParameters,\n\t\t\toInnerAppData,\n\t\t\tfnOnError,\n\t\t\toExternalAppData,\n\t\t\tsNavMode\n\t\t);\n\t}\n\t/**\n\t * Parses the incoming URL and returns a Promise.\n\t *\n\t * @returns A Promise object which returns the\n\t * extracted app state, the startup parameters, and the type of navigation when execution is successful,\n\t * @private\n\t * @ui5-restricted\n\t */\n\tparseNavigation() {\n\t\treturn this.oNavHandler.parseNavigation();\n\t}\n\t/**\n\t * Processes navigation-related tasks related to beforePopoverOpens event handling for the SmartLink control and returns a Promise object.\n\t *\n\t * @param oTableEventParameters The parameters made available by the SmartTable control when the SmartLink control has been clicked,\n\t *        an instance of a PopOver object\n\t * @param sSelectionVariant Stringified JSON object as returned, for example, from getDataSuiteFormat() of the SmartFilterBar control\n\t * @param [mInnerAppData] Object containing the current state of the app. If provided, opening the Popover is deferred until the\n\t *        inner app data is saved in a consistent way.\n\t * @returns A Promise object to monitor when all actions of the function have been executed; if the execution is successful, the\n\t *          modified oTableEventParameters is returned; if an error occurs, an error object of type\n\t *          {@link sap.fe.navigation.NavError} is returned\n\t * @private\n\t */\n\t_processBeforeSmartLinkPopoverOpens(oTableEventParameters: object, sSelectionVariant: string, mInnerAppData?: InnerAppData) {\n\t\treturn this.oNavHandler.processBeforeSmartLinkPopoverOpens(oTableEventParameters, sSelectionVariant, mInnerAppData);\n\t}\n\n\t/**\n\t * Processes selectionVariant string and returns a Promise object (semanticAttributes and AppStateKey).\n\t *\n\t * @param sSelectionVariant Stringified JSON object\n\t * @returns A Promise object to monitor when all actions of the function have been executed; if the execution is successful, the\n\t *          semanticAttributes as well as the appStateKey are returned; if an error occurs, an error object of type\n\t *          {@link sap.fe.navigation.NavError} is returned\n\t * <br>\n\t * @example <code>\n\t *\n\t * \t\tvar oSelectionVariant = new sap.fe.navigation.SelectionVariant();\n\t * \t\toSelectionVariant.addSelectOption(\"CompanyCode\", \"I\", \"EQ\", \"0001\");\n\t * \t\toSelectionVariant.addSelectOption(\"Customer\", \"I\", \"EQ\", \"C0001\");\n\t * \t\tvar sSelectionVariant= oSelectionVariant.toJSONString();\n\t *\n\t * \t\tvar oNavigationHandler = new sap.fe.navigation.NavigationHandler(oController);\n\t * \t\tvar oPromiseObject = oNavigationHandler._getAppStateKeyAndUrlParameters(sSelectionVariant);\n\t *\n\t * \t\toPromiseObject.done(function(oSemanticAttributes, sAppStateKey){\n\t * \t\t\t// here you can add coding that should run after all app state and the semantic attributes have been returned.\n\t * \t\t});\n\t *\n\t * \t\toPromiseObject.fail(function(oError){\n\t * \t\t\t//some error handling\n\t * \t\t});\n\t *\n\t * </code>\n\t * @private\n\t * @ui5-restricted\n\t */\n\tgetAppStateKeyAndUrlParameters(sSelectionVariant: string) {\n\t\treturn this.oNavHandler._getAppStateKeyAndUrlParameters(sSelectionVariant);\n\t}\n\n\t/**\n\t * Gets the application specific technical parameters.\n\t *\n\t * @returns Containing the technical parameters.\n\t * @private\n\t * @ui5-restricted\n\t */\n\tgetTechnicalParameters() {\n\t\treturn this.oNavHandler.getTechnicalParameters();\n\t}\n\t/**\n\t * Sets the application specific technical parameters. Technical parameters will not be added to the selection variant passed to the\n\t * application.\n\t * As a default sap-system, sap-ushell-defaultedParameterNames and hcpApplicationId are considered as technical parameters.\n\t *\n\t * @param aTechnicalParameters List of parameter names to be considered as technical parameters. <code>null</code> or\n\t *        <code>undefined</code> may be used to reset the complete list.\n\t * @private\n\t * @ui5-restricted\n\t */\n\tsetTechnicalParameters(aTechnicalParameters: any[]) {\n\t\tthis.oNavHandler.setTechnicalParameters(aTechnicalParameters);\n\t}\n\t/**\n\t * Sets the model that is used for verification of sensitive information. If the model is not set, the unnamed component model is used for the\n\t * verification of sensitive information.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param oModel Model For checking sensitive information\n\t */\n\tsetModel(oModel: any) {\n\t\tthis.oNavHandler.setModel(oModel);\n\t}\n\t/**\n\t * Changes the URL according to the current app state and stores the app state for later retrieval.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param mInnerAppData Object containing the current state of the app\n\t * @param [bImmediateHashReplace=true] If set to false, the inner app hash will not be replaced until storing is successful; do not\n\t *        set to false if you cannot react to the resolution of the Promise, for example, when calling the beforeLinkPressed event\n\t * @param [bSkipHashReplace=false] If set to true, the inner app hash will not be replaced in the storeInnerAppState. Also the bImmediateHashReplace\n\t * \t\t  will be ignored.\n\t * @returns A Promise object to monitor when all the actions of the function have been executed; if the execution is successful, the\n\t *          app state key is returned; if an error occurs, an object of type {@link sap.fe.navigation.NavError} is\n\t *          returned\n\t */\n\tstoreInnerAppStateAsync(mInnerAppData: InnerAppData, bImmediateHashReplace?: boolean, bSkipHashReplace?: boolean): Promise<string> {\n\t\t// safely converting JQuerry deferred to ES6 promise\n\t\treturn new Promise((resolve, reject) =>\n\t\t\tthis.oNavHandler.storeInnerAppStateAsync(mInnerAppData, bImmediateHashReplace, bSkipHashReplace).then(resolve, reject)\n\t\t);\n\t}\n\t/**\n\t * Changes the URL according to the current app state and stores the app state for later retrieval.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param mInnerAppData Object containing the current state of the app\n\t * @param [bImmediateHashReplace=false] If set to false, the inner app hash will not be replaced until storing is successful; do not\n\t * @returns An object containing the appStateId and a promise object to monitor when all the actions of the function have been\n\t * executed; Please note that the appStateKey may be undefined or empty.\n\t */\n\tstoreInnerAppStateWithImmediateReturn(mInnerAppData: any, bImmediateHashReplace: boolean | undefined) {\n\t\treturn this.oNavHandler.storeInnerAppStateWithImmediateReturn(mInnerAppData, bImmediateHashReplace);\n\t}\n\t/**\n\t * Changes the URL according to the current sAppStateKey. As an reaction route change event will be triggered.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param sAppStateKey The new app state key.\n\t */\n\treplaceHash(sAppStateKey: string) {\n\t\tthis.oNavHandler.replaceHash(sAppStateKey);\n\t}\n\treplaceInnerAppStateKey(sAppHash: any, sAppStateKey: any) {\n\t\treturn this.oNavHandler._replaceInnerAppStateKey(sAppHash, sAppStateKey);\n\t}\n\t/**\n\t * Get single values from SelectionVariant for url parameters.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param [vSelectionVariant]\n\t * @param [vSelectionVariant.oUrlParamaters]\n\t * @returns The url parameters\n\t */\n\tgetUrlParametersFromSelectionVariant(vSelectionVariant: string | object | undefined) {\n\t\treturn this.oNavHandler._getURLParametersFromSelectionVariant(vSelectionVariant);\n\t}\n\n\t/**\n\t * Save app state and return immediately without waiting for response.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param oInSelectionVariant Instance of sap.fe.navigation.SelectionVariant\n\t * @returns AppState key\n\t */\n\tsaveAppStateWithImmediateReturn(oInSelectionVariant: SelectionVariant): string | undefined {\n\t\tif (oInSelectionVariant) {\n\t\t\tconst sSelectionVariant = oInSelectionVariant.toJSONString(), // create an SV for app state in string format\n\t\t\t\toSelectionVariant = JSON.parse(sSelectionVariant), // convert string into JSON to store in AppState\n\t\t\t\toXAppStateObject = {\n\t\t\t\t\tselectionVariant: oSelectionVariant\n\t\t\t\t},\n\t\t\t\toReturn = this.oNavHandler._saveAppStateWithImmediateReturn(oXAppStateObject);\n\t\t\treturn oReturn?.appStateKey ? oReturn.appStateKey : \"\";\n\t\t} else {\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\t/**\n\t * Mix Attributes and selectionVariant.\n\t *\n\t * @param vSemanticAttributes Object/(Array of Objects) containing key/value pairs\n\t * @param sSelectionVariant The selection variant in string format as provided by the SmartFilterBar control\n\t * @param [iSuppressionBehavior=sap.fe.navigation.SuppressionBehavior.standard] Indicates whether semantic\n\t *        attributes with special values (see {@link sap.fe.navigation.SuppressionBehavior suppression behavior}) must be\n\t *        suppressed before they are combined with the selection variant; several\n\t *        {@link sap.fe.navigation.SuppressionBehavior suppression behaviors} can be combined with the bitwise OR operator\n\t *        (|)\n\t * @returns Instance of {@link sap.fe.navigation.SelectionVariant}\n\t */\n\tmixAttributesAndSelectionVariant(\n\t\tvSemanticAttributes: object | any[],\n\t\tsSelectionVariant: string | SerializedSelectionVariant,\n\t\tiSuppressionBehavior?: number\n\t) {\n\t\treturn this.oNavHandler.mixAttributesAndSelectionVariant(vSemanticAttributes, sSelectionVariant, iSuppressionBehavior);\n\t}\n\n\t/**\n\t * The method creates a context url based on provided data. This context url can either be used as.\n\t *\n\t * @param sEntitySetName Used for url determination\n\t * @param [oModel] The ODataModel used for url determination. If omitted, the NavigationHandler model is used.\n\t * @returns The context url for the given entities\n\t */\n\tconstructContextUrl(sEntitySetName: string, oModel: any) {\n\t\treturn this.oNavHandler.constructContextUrl(sEntitySetName, oModel);\n\t}\n\tgetInterface() {\n\t\treturn this;\n\t}\n}\nfunction fnGetEmptyObject() {\n\treturn {};\n}\n\nfunction fnGetPromise() {\n\treturn Promise.resolve({});\n}\n\nfunction fnGetJQueryPromise() {\n\tconst oMyDeffered = jQuery.Deferred();\n\toMyDeffered.resolve({}, {}, \"initial\");\n\treturn oMyDeffered.promise();\n}\n\nfunction fnGetEmptyString() {\n\treturn \"\";\n}\nexport class NavigationServicesMock {\n\tinitPromise: Promise<any>;\n\tconstructor() {\n\t\tthis.initPromise = Promise.resolve(this);\n\t}\n\n\tgetInterface() {\n\t\treturn this;\n\t}\n\n\t// return empty object\n\tcreateEmptyAppState = fnGetEmptyObject;\n\tstoreInnerAppStateWithImmediateReturn = fnGetEmptyObject;\n\tmixAttributesAndSelectionVariant = fnGetEmptyObject;\n\n\t// return promise\n\tgetAppState = fnGetPromise;\n\tgetStartupAppState = fnGetPromise;\n\tparseNavigation = fnGetJQueryPromise;\n\n\t// return empty string\n\tconstructContextUrl = fnGetEmptyString;\n\n\treplaceInnerAppStateKey(sAppHash: any) {\n\t\treturn sAppHash ? sAppHash : \"\";\n\t}\n\n\tnavigate() {\n\t\t// Don't do anything\n\t}\n}\n\nclass NavigationServiceFactory extends ServiceFactory<NavigationServiceSettings> {\n\tcreateInstance(oServiceContext: ServiceContext<NavigationServiceSettings>) {\n\t\tconst oNavigationService =\n\t\t\tsap.ushell && sap.ushell.Container ? new NavigationService(oServiceContext) : new NavigationServicesMock();\n\t\t// Wait For init\n\t\treturn oNavigationService.initPromise.then(function (oService: any) {\n\t\t\treturn oService;\n\t\t});\n\t}\n}\n\nexport default NavigationServiceFactory;\n"],"mappings":"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"}