@sap/open.fe 1.94.0

package/packages/sap.fe.core/src/sap/fe/core/services/ShellServicesFactory-dbg.js

@@ -0,0 +1,819 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/ui/core/service/ServiceFactory", "sap/ui/core/service/Service"], function (ServiceFactory, Service) {
+  "use strict";
+
+  function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+  function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+  function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+  function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  /**
+   * Mock implementation of the ShellService for OpenFE
+   *
+   * @implements {IShellServices}
+   * @private
+   */
+  var ShellServiceMock = /*#__PURE__*/function (_Service) {
+    _inherits(ShellServiceMock, _Service);
+
+    var _super = _createSuper(ShellServiceMock);
+
+    function ShellServiceMock() {
+      _classCallCheck(this, ShellServiceMock);
+
+      return _super.apply(this, arguments);
+    }
+
+    _createClass(ShellServiceMock, [{
+      key: "init",
+      value: function init() {
+        this.initPromise = Promise.resolve(this);
+        this.instanceType = "mock";
+      }
+    }, {
+      key: "getLinks",
+      value: function getLinks(oArgs) {
+        return Promise.resolve([]);
+      }
+    }, {
+      key: "getLinksWithCache",
+      value: function getLinksWithCache(oArgs) {
+        return Promise.resolve([]);
+      }
+    }, {
+      key: "toExternal",
+      value: function toExternal(oNavArgumentsArr, oComponent) {
+        return;
+      }
+    }, {
+      key: "getStartupAppState",
+      value: function getStartupAppState(oArgs) {
+        return Promise.resolve(null);
+      }
+    }, {
+      key: "backToPreviousApp",
+      value: function backToPreviousApp() {
+        return;
+      }
+    }, {
+      key: "hrefForExternal",
+      value: function hrefForExternal(oArgs, oComponent, bAsync) {
+        return "";
+      }
+    }, {
+      key: "getAppState",
+      value: function getAppState(oComponent, sAppStateKey) {
+        return Promise.resolve({});
+      }
+    }, {
+      key: "createEmptyAppState",
+      value: function createEmptyAppState(oComponent) {
+        return Promise.resolve({});
+      }
+    }, {
+      key: "isNavigationSupported",
+      value: function isNavigationSupported(oNavArgumentsArr, oComponent) {
+        return Promise.resolve({});
+      }
+    }, {
+      key: "isInitialNavigation",
+      value: function isInitialNavigation() {
+        return false;
+      }
+    }, {
+      key: "expandCompactHash",
+      value: function expandCompactHash(sHashFragment) {
+        return Promise.resolve({});
+      }
+    }, {
+      key: "parseShellHash",
+      value: function parseShellHash(sHash) {
+        return {};
+      }
+    }, {
+      key: "splitHash",
+      value: function splitHash(sHash) {
+        return Promise.resolve({});
+      }
+    }, {
+      key: "constructShellHash",
+      value: function constructShellHash(oNewShellHash) {
+        return "";
+      }
+    }, {
+      key: "setDirtyFlag",
+      value: function setDirtyFlag(bDirty) {
+        return;
+      }
+    }, {
+      key: "registerDirtyStateProvider",
+      value: function registerDirtyStateProvider(fnDirtyStateProvider) {
+        return;
+      }
+    }, {
+      key: "deregisterDirtyStateProvider",
+      value: function deregisterDirtyStateProvider(fnDirtyStateProvider) {
+        return;
+      }
+    }, {
+      key: "createRenderer",
+      value: function createRenderer() {
+        return {};
+      }
+    }, {
+      key: "getUser",
+      value: function getUser() {
+        return {};
+      }
+    }, {
+      key: "hasUShell",
+      value: function hasUShell() {
+        return false;
+      }
+    }, {
+      key: "registerNavigationFilter",
+      value: function registerNavigationFilter(fnNavFilter) {
+        return;
+      }
+    }, {
+      key: "unregisterNavigationFilter",
+      value: function unregisterNavigationFilter(fnNavFilter) {
+        return;
+      }
+    }, {
+      key: "setBackNavigation",
+      value: function setBackNavigation(fnCallBack) {
+        return;
+      }
+    }, {
+      key: "setHierarchy",
+      value: function setHierarchy(aHierarchyLevels) {
+        return;
+      }
+    }, {
+      key: "setTitle",
+      value: function setTitle(sTitle) {
+        return;
+      }
+    }, {
+      key: "getContentDensity",
+      value: function getContentDensity() {
+        // in case there is no shell we probably need to look at the classes being defined on the body
+        if (document.body.classList.contains("sapUiSizeCozy")) {
+          return "cozy";
+        } else if (document.body.classList.contains("sapUiSizeCompact")) {
+          return "compact";
+        } else {
+          return "";
+        }
+      }
+    }]);
+
+    return ShellServiceMock;
+  }(Service);
+  /**
+   * @typedef ShellServicesSettings
+   * @private
+   */
+
+
+  /**
+   * Wrap a JQuery Promise within a native {Promise}.
+   *
+   * @template {object} T
+   * @param {jQuery.Promise<T>} jqueryPromise The original jquery promise
+   * @returns {Promise<T>} A native promise wrapping the same object
+   * @private
+   */
+  function wrapJQueryPromise(jqueryPromise) {
+    return new Promise(function (resolve, reject) {
+      // eslint-disable-next-line promise/catch-or-return
+      jqueryPromise.done(resolve).fail(reject);
+    });
+  }
+  /**
+   * Base implementation of the ShellServices
+   *
+   * @implements {IShellServices}
+   * @private
+   */
+
+
+  var ShellServices = /*#__PURE__*/function (_Service2) {
+    _inherits(ShellServices, _Service2);
+
+    var _super2 = _createSuper(ShellServices);
+
+    function ShellServices() {
+      _classCallCheck(this, ShellServices);
+
+      return _super2.apply(this, arguments);
+    }
+
+    _createClass(ShellServices, [{
+      key: "init",
+      value: // !: means that we know it will be assigned before usage
+      function init() {
+        var _this = this;
+
+        var oContext = this.getContext();
+        var oComponent = oContext.scopeObject;
+        this.oShellContainer = oContext.settings.shellContainer;
+        this.instanceType = "real";
+        this.linksCache = {};
+
+        this.fnFindSemanticObjectsInCache = function (oArgs) {
+          var _oArgs = oArgs;
+          var aCachedSemanticObjects = [];
+          var aNonCachedSemanticObjects = [];
+
+          for (var i = 0; i < _oArgs.length; i++) {
+            if (!!_oArgs[i][0] && !!_oArgs[i][0].semanticObject) {
+              if (this.linksCache[_oArgs[i][0].semanticObject]) {
+                aCachedSemanticObjects.push(this.linksCache[_oArgs[i][0].semanticObject].links);
+                Object.defineProperty(oArgs[i][0], "links", {
+                  value: this.linksCache[_oArgs[i][0].semanticObject].links
+                });
+              } else {
+                aNonCachedSemanticObjects.push(_oArgs[i]);
+              }
+            }
+          }
+
+          return {
+            oldArgs: oArgs,
+            newArgs: aNonCachedSemanticObjects,
+            cachedLinks: aCachedSemanticObjects
+          };
+        };
+
+        this.initPromise = new Promise(function (resolve, reject) {
+          _this.resolveFn = resolve;
+          _this.rejectFn = reject;
+        });
+        var oCrossAppNavServicePromise = this.oShellContainer.getServiceAsync("CrossApplicationNavigation");
+        var oUrlParsingServicePromise = this.oShellContainer.getServiceAsync("URLParsing");
+        var oShellNavigationServicePromise = this.oShellContainer.getServiceAsync("ShellNavigation");
+        var oShellUIServicePromise = oComponent.getService("ShellUIService");
+        Promise.all([oCrossAppNavServicePromise, oUrlParsingServicePromise, oShellNavigationServicePromise, oShellUIServicePromise]).then(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 4),
+              oCrossAppNavService = _ref2[0],
+              oUrlParsingService = _ref2[1],
+              oShellNavigation = _ref2[2],
+              oShellUIService = _ref2[3];
+
+          _this.crossAppNavService = oCrossAppNavService;
+          _this.urlParsingService = oUrlParsingService;
+          _this.shellNavigation = oShellNavigation;
+          _this.shellUIService = oShellUIService;
+
+          _this.resolveFn();
+        }).catch(this.rejectFn);
+      }
+      /**
+       * Retrieves the target links configured for a given semantic object & action
+       * Will retrieve the CrossApplicationNavigation
+       * service reference call the getLinks method. In case service is not available or any exception
+       * method throws exception error in console.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} oArgs Check the definition of
+       * sap.ushell.services.CrossApplicationNavigation=>getLinks arguments
+       * @returns {Promise} Promise which will be resolved to target links array
+       */
+
+    }, {
+      key: "getLinks",
+      value: function getLinks(oArgs) {
+        var _this2 = this;
+
+        return new Promise(function (resolve, reject) {
+          // eslint-disable-next-line promise/catch-or-return
+          _this2.crossAppNavService.getLinks(oArgs).fail(function (oError) {
+            reject(new Error(oError + " sap.fe.core.services.NavigationServiceFactory.getLinks"));
+          }).then(resolve);
+        });
+      }
+      /**
+       * Retrieves the target links configured for a given semantic object & action in cache
+       * Will retrieve the CrossApplicationNavigation
+       * service reference call the getLinks method. In case service is not available or any exception
+       * method throws exception error in console.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} oArgs Check the definition of
+       * sap.ushell.services.CrossApplicationNavigation=>getLinks arguments
+       * @returns {Promise} Promise which will be resolved to target links array
+       */
+
+    }, {
+      key: "getLinksWithCache",
+      value: function getLinksWithCache(oArgs) {
+        var _this3 = this;
+
+        return new Promise(function (resolve, reject) {
+          // eslint-disable-next-line promise/catch-or-return
+          if (oArgs.length === 0) {
+            resolve([]);
+          } else {
+            var aLinks;
+
+            var oCacheResults = _this3.fnFindSemanticObjectsInCache(oArgs);
+
+            if (oCacheResults.newArgs.length === 0) {
+              resolve(oCacheResults.cachedLinks);
+            } else {
+              // eslint-disable-next-line promise/catch-or-return
+              _this3.crossAppNavService.getLinks(oCacheResults.newArgs).fail(function (oError) {
+                reject(new Error(oError + " sap.fe.core.services.NavigationServiceFactory.getLinksWithCache"));
+              }).then(function (aLinks) {
+                if (aLinks.length !== 0) {
+                  var oSemanticObjectsLinks = {};
+
+                  for (var i = 0; i < aLinks.length; i++) {
+                    if (aLinks[i].length > 0 && oCacheResults.newArgs[i][0].links === undefined) {
+                      oSemanticObjectsLinks[oCacheResults.newArgs[i][0].semanticObject] = {
+                        links: aLinks[i]
+                      };
+                      _this3.linksCache = Object.assign(_this3.linksCache, oSemanticObjectsLinks);
+                    }
+                  }
+                }
+
+                if (oCacheResults.cachedLinks.length === 0) {
+                  resolve(aLinks);
+                } else {
+                  var aMergedLinks = [];
+                  var j = 0;
+
+                  for (var k = 0; k < oCacheResults.oldArgs.length; k++) {
+                    if (j < aLinks.length) {
+                      if (aLinks[j].length > 0 && oCacheResults.oldArgs[k][0].semanticObject === oCacheResults.newArgs[j][0].semanticObject) {
+                        aMergedLinks.push(aLinks[j]);
+                        j++;
+                      } else {
+                        aMergedLinks.push(oCacheResults.oldArgs[k][0].links);
+                      }
+                    } else {
+                      aMergedLinks.push(oCacheResults.oldArgs[k][0].links);
+                    }
+                  }
+
+                  resolve(aMergedLinks);
+                }
+              });
+            }
+          }
+        });
+      }
+      /**
+       * Will retrieve the ShellContainer.
+       *
+       * @private
+       * @ui5-restricted
+       * sap.ushell.container
+       * @returns {object} Object with predefined shellContainer methods
+       */
+
+    }, {
+      key: "getShellContainer",
+      value: function getShellContainer() {
+        return this.oShellContainer;
+      }
+      /**
+       * Will call toExternal method of CrossApplicationNavigation service with Navigation Arguments and oComponent.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {Array} oNavArgumentsArr And
+       * @param {object} oComponent Check the definition of
+       * sap.ushell.services.CrossApplicationNavigation=>toExternal arguments
+       * @returns {void}
+       */
+
+    }, {
+      key: "toExternal",
+      value: function toExternal(oNavArgumentsArr, oComponent) {
+        this.crossAppNavService.toExternal(oNavArgumentsArr, oComponent);
+      }
+      /**
+       * Retrieves the target startupAppState
+       * Will check the existance of the ShellContainer and retrieve the CrossApplicationNavigation
+       * service reference call the getStartupAppState method. In case service is not available or any exception
+       * method throws exception error in console.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} oArgs Check the definition of
+       * sap.ushell.services.CrossApplicationNavigation=>getStartupAppState arguments
+       * @returns {Promise} Promise which will be resolved to Object
+       */
+
+    }, {
+      key: "getStartupAppState",
+      value: function getStartupAppState(oArgs) {
+        var _this4 = this;
+
+        return new Promise(function (resolve, reject) {
+          // JQuery Promise behaves differently
+          // eslint-disable-next-line promise/catch-or-return
+          _this4.crossAppNavService.getStartupAppState(oArgs).fail(function (oError) {
+            reject(new Error(oError + " sap.fe.core.services.NavigationServiceFactory.getStartupAppState"));
+          }).then(resolve);
+        });
+      }
+      /**
+       * Will call backToPreviousApp method of CrossApplicationNavigation service.
+       *
+       * @returns {void}
+       * @private
+       * @ui5-restricted
+       */
+
+    }, {
+      key: "backToPreviousApp",
+      value: function backToPreviousApp() {
+        return this.crossAppNavService.backToPreviousApp();
+      }
+      /**
+       * Will call hrefForExternal method of CrossApplicationNavigation service.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} oArgs Check the definition of
+       * @param {object} oComponent The appComponent
+       * @param {boolean} bAsync Whether this call should be async or not
+       * sap.ushell.services.CrossApplicationNavigation=>hrefForExternal arguments
+       * @returns {string} Promise which will be resolved to string
+       */
+
+    }, {
+      key: "hrefForExternal",
+      value: function hrefForExternal(oArgs, oComponent, bAsync) {
+        return this.crossAppNavService.hrefForExternal(oArgs, oComponent, !!bAsync);
+      }
+      /**
+       * Will call getAppState method of CrossApplicationNavigation service with oComponent and oAppStateKey.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} oComponent
+       * @param {string} sAppStateKey Check the definition of
+       * sap.ushell.services.CrossApplicationNavigation=>getAppState arguments
+       * @returns {Promise} Promise which will be resolved to object
+       */
+
+    }, {
+      key: "getAppState",
+      value: function getAppState(oComponent, sAppStateKey) {
+        return wrapJQueryPromise(this.crossAppNavService.getAppState(oComponent, sAppStateKey));
+      }
+      /**
+       * Will call createEmptyAppState method of CrossApplicationNavigation service with oComponent.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} oComponent Check the definition of
+       * sap.ushell.services.CrossApplicationNavigation=>createEmptyAppState arguments
+       * @returns {Promise} Promise which will be resolved to object
+       */
+
+    }, {
+      key: "createEmptyAppState",
+      value: function createEmptyAppState(oComponent) {
+        return this.crossAppNavService.createEmptyAppState(oComponent);
+      }
+      /**
+       * Will call isNavigationSupported method of CrossApplicationNavigation service with Navigation Arguments and oComponent.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {Array} oNavArgumentsArr
+       * @param {object} oComponent Check the definition of
+       * sap.ushell.services.CrossApplicationNavigation=>isNavigationSupported arguments
+       * @returns {Promise} Promise which will be resolved to object
+       */
+
+    }, {
+      key: "isNavigationSupported",
+      value: function isNavigationSupported(oNavArgumentsArr, oComponent) {
+        return wrapJQueryPromise(this.crossAppNavService.isNavigationSupported(oNavArgumentsArr, oComponent));
+      }
+      /**
+       * Will call isInitialNavigation method of CrossApplicationNavigation service.
+       *
+       * @private
+       * @ui5-restricted
+       * @returns {Promise} Promise which will be resolved to boolean
+       */
+
+    }, {
+      key: "isInitialNavigation",
+      value: function isInitialNavigation() {
+        return this.crossAppNavService.isInitialNavigation();
+      }
+      /**
+       * Will call expandCompactHash method of CrossApplicationNavigation service.
+       *
+       * @param {string} sHashFragment An (internal format) shell hash
+       * @returns {Promise} A promise the success handler of the resolve promise get an expanded shell hash as first argument
+       * @private
+       * @ui5-restricted
+       */
+
+    }, {
+      key: "expandCompactHash",
+      value: function expandCompactHash(sHashFragment) {
+        return this.crossAppNavService.expandCompactHash(sHashFragment);
+      }
+      /**
+       * Will call parseShellHash method of URLParsing service with given sHash.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {string} sHash Check the definition of
+       * sap.ushell.services.URLParsing=>parseShellHash arguments
+       * @returns {object}
+       */
+
+    }, {
+      key: "parseShellHash",
+      value: function parseShellHash(sHash) {
+        return this.urlParsingService.parseShellHash(sHash);
+      }
+      /**
+       * Will call splitHash method of URLParsing service with given sHash.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {string} sHash Check the definition of
+       * sap.ushell.services.URLParsing=>splitHash arguments
+       * @returns {Promise} Promise which will be resolved to object
+       */
+
+    }, {
+      key: "splitHash",
+      value: function splitHash(sHash) {
+        return this.urlParsingService.splitHash(sHash);
+      }
+      /**
+       * Will call constructShellHash method of URLParsing service with given sHash.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {object} oNewShellHash Check the definition of
+       * sap.ushell.services.URLParsing=>constructShellHash arguments
+       * @returns {string} Shell Hash string
+       */
+
+    }, {
+      key: "constructShellHash",
+      value: function constructShellHash(oNewShellHash) {
+        return this.urlParsingService.constructShellHash(oNewShellHash);
+      }
+      /**
+       * Will call setDirtyFlag method with given dirty state.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {boolean} bDirty Check the definition of sap.ushell.Container.setDirtyFlag arguments
+       */
+
+    }, {
+      key: "setDirtyFlag",
+      value: function setDirtyFlag(bDirty) {
+        this.oShellContainer.setDirtyFlag(bDirty);
+      }
+      /**
+       * Will call registerDirtyStateProvider method with given dirty state provider callback method.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {Function} fnDirtyStateProvider Check the definition of sap.ushell.Container.registerDirtyStateProvider arguments
+       */
+
+    }, {
+      key: "registerDirtyStateProvider",
+      value: function registerDirtyStateProvider(fnDirtyStateProvider) {
+        this.oShellContainer.registerDirtyStateProvider(fnDirtyStateProvider);
+      }
+      /**
+       * Will call deregisterDirtyStateProvider method with given dirty state provider callback method.
+       *
+       * @private
+       * @ui5-restricted
+       * @param {Function} fnDirtyStateProvider Check the definition of sap.ushell.Container.deregisterDirtyStateProvider arguments
+       */
+
+    }, {
+      key: "deregisterDirtyStateProvider",
+      value: function deregisterDirtyStateProvider(fnDirtyStateProvider) {
+        this.oShellContainer.deregisterDirtyStateProvider(fnDirtyStateProvider);
+      }
+      /**
+       * Will call createRenderer method of ushell container.
+       *
+       * @private
+       * @ui5-restricted
+       * @returns {object} Returns renderer object
+       */
+
+    }, {
+      key: "createRenderer",
+      value: function createRenderer() {
+        return this.oShellContainer.createRenderer();
+      }
+      /**
+       * Will call getUser method of ushell container.
+       *
+       * @private
+       * @ui5-restricted
+       * @returns {object} Returns User object
+       */
+
+    }, {
+      key: "getUser",
+      value: function getUser() {
+        return this.oShellContainer.getUser();
+      }
+      /**
+       * Will check if ushell container is available or not.
+       *
+       * @private
+       * @ui5-restricted
+       * @returns {boolean} Returns true
+       */
+
+    }, {
+      key: "hasUShell",
+      value: function hasUShell() {
+        return true;
+      }
+      /**
+       * Will call registerNavigationFilter method of shellNavigation.
+       *
+       * @param {Function} fnNavFilter The filter function to register
+       * @returns {void}
+       * @private
+       * @ui5-restricted
+       */
+
+    }, {
+      key: "registerNavigationFilter",
+      value: function registerNavigationFilter(fnNavFilter) {
+        this.shellNavigation.registerNavigationFilter(fnNavFilter);
+      }
+      /**
+       * Will call unregisterNavigationFilter method of shellNavigation.
+       *
+       * @param {Function} fnNavFilter The filter function to unregister
+       * @returns {void}
+       * @private
+       * @ui5-restricted
+       */
+
+    }, {
+      key: "unregisterNavigationFilter",
+      value: function unregisterNavigationFilter(fnNavFilter) {
+        this.shellNavigation.unregisterNavigationFilter(fnNavFilter);
+      }
+      /**
+       * Will call setBackNavigation method of ShellUIService
+       * that displays the back button in the shell header.
+       *
+       * @param {Function} [fnCallBack] A callback function called when the button is clicked in the UI.
+       * @returns {void}
+       * @private
+       * @ui5-restricted
+       */
+
+    }, {
+      key: "setBackNavigation",
+      value: function setBackNavigation(fnCallBack) {
+        this.shellUIService.setBackNavigation(fnCallBack);
+      }
+      /**
+       * Will call setHierarchy method of ShellUIService
+       * that displays the given hierarchy in the shell header.
+       *
+       * @param {object[]} [aHierarchyLevels] An array representing hierarchies of the currently displayed app.
+       * @returns {void}
+       * @private
+       * @ui5-restricted
+       */
+
+    }, {
+      key: "setHierarchy",
+      value: function setHierarchy(aHierarchyLevels) {
+        this.shellUIService.setHierarchy(aHierarchyLevels);
+      }
+      /**
+       * Will call setTitle method of ShellUIService
+       * that displays the given title in the shell header.
+       *
+       * @param {string} [sTitle] The new title. The default title is set if this argument is not given.
+       * @returns {void}
+       * @private
+       * @ui5-restricted
+       */
+
+    }, {
+      key: "setTitle",
+      value: function setTitle(sTitle) {
+        this.shellUIService.setTitle(sTitle);
+      }
+      /**
+       * Retrieves the currently defined content density.
+       *
+       * @returns {string} The content density value
+       */
+
+    }, {
+      key: "getContentDensity",
+      value: function getContentDensity() {
+        return this.oShellContainer.getUser().getContentDensity();
+      }
+    }]);
+
+    return ShellServices;
+  }(Service);
+  /**
+   * Service Factory for the ShellServices
+   *
+   * @private
+   */
+
+
+  var ShellServicesFactory = /*#__PURE__*/function (_ServiceFactory) {
+    _inherits(ShellServicesFactory, _ServiceFactory);
+
+    var _super3 = _createSuper(ShellServicesFactory);
+
+    function ShellServicesFactory() {
+      _classCallCheck(this, ShellServicesFactory);
+
+      return _super3.apply(this, arguments);
+    }
+
+    _createClass(ShellServicesFactory, [{
+      key: "createInstance",
+      value:
+      /**
+       * Creates either a standard or a mock Shell service depending on the configuration.
+       *
+       * @param {ServiceContext<ShellServicesSettings>} oServiceContext The shellservice context
+       * @returns {Promise<IShellServices>} A promise for a shell service implementation
+       * @see ServiceFactory#createInstance
+       */
+      function createInstance(oServiceContext) {
+        oServiceContext.settings.shellContainer = sap.ushell && sap.ushell.Container;
+        var oShellService = oServiceContext.settings.shellContainer ? new ShellServices(oServiceContext) : new ShellServiceMock(oServiceContext);
+        return oShellService.initPromise.then(function () {
+          // Enrich the appComponent with this method
+          oServiceContext.scopeObject.getShellServices = function () {
+            return oShellService;
+          };
+
+          return oShellService;
+        });
+      }
+    }]);
+
+    return ShellServicesFactory;
+  }(ServiceFactory);
+
+  return ShellServicesFactory;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["ShellServicesFactory.ts"],"names":["ShellServiceMock","initPromise","Promise","resolve","instanceType","oArgs","oNavArgumentsArr","oComponent","bAsync","sAppStateKey","sHashFragment","sHash","oNewShellHash","bDirty","fnDirtyStateProvider","fnNavFilter","fnCallBack","aHierarchyLevels","sTitle","document","body","classList","contains","Service","wrapJQueryPromise","jqueryPromise","reject","done","fail","ShellServices","oContext","getContext","scopeObject","oShellContainer","settings","shellContainer","linksCache","fnFindSemanticObjectsInCache","_oArgs","aCachedSemanticObjects","aNonCachedSemanticObjects","i","length","semanticObject","push","links","Object","defineProperty","value","oldArgs","newArgs","cachedLinks","resolveFn","rejectFn","oCrossAppNavServicePromise","getServiceAsync","oUrlParsingServicePromise","oShellNavigationServicePromise","oShellUIServicePromise","getService","all","then","oCrossAppNavService","oUrlParsingService","oShellNavigation","oShellUIService","crossAppNavService","urlParsingService","shellNavigation","shellUIService","catch","getLinks","oError","Error","aLinks","oCacheResults","oSemanticObjectsLinks","undefined","assign","aMergedLinks","j","k","toExternal","getStartupAppState","backToPreviousApp","hrefForExternal","getAppState","createEmptyAppState","isNavigationSupported","isInitialNavigation","expandCompactHash","parseShellHash","splitHash","constructShellHash","setDirtyFlag","registerDirtyStateProvider","deregisterDirtyStateProvider","createRenderer","getUser","registerNavigationFilter","unregisterNavigationFilter","setBackNavigation","setHierarchy","setTitle","getContentDensity","ShellServicesFactory","oServiceContext","sap","ushell","Container","oShellService","getShellServices","ServiceFactory"],"mappings":"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iBAAL,CAAuBwB,cAAvB,CAAsChF,KAAtC,CAAP;AACA;AAED;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;aACC,mBAAUA,KAAV,EAAyB;AACxB,eAAO,KAAKwD,iBAAL,CAAuByB,SAAvB,CAAiCjF,KAAjC,CAAP;AACA;AAED;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;aACC,4BAAmBC,aAAnB,EAA0C;AACzC,eAAO,KAAKuD,iBAAL,CAAuB0B,kBAAvB,CAA0CjF,aAA1C,CAAP;AACA;AAED;AACD;AACA;AACA;AACA;AACA;AACA;;;;aACC,sBAAaC,MAAb,EAA8B;AAC7B,aAAKoB,eAAL,CAAqB6D,YAArB,CAAkCjF,MAAlC;AACA;AAED;AACD;AACA;AACA;AACA;AACA;AACA;;;;aACC,oCAA2BC,oBAA3B,EAA2D;AAC1D,aAAKmB,eAAL,CAAqB8D,0BAArB,CAAgDjF,oBAAhD;AACA;AAED;AACD;AACA;AACA;AACA;AACA;AACA;;;;aACC,sCAA6BA,oBAA7B,EAA6D;AAC5D,aAAKmB,eAAL,CAAqB+D,4BAArB,CAAkDlF,oBAAlD;AACA;AAED;AACD;AACA;AACA;AACA;AACA;AACA;;;;aACC,0BAAiB;AAChB,eAAO,KAAKmB,eAAL,CAAqBgE,cAArB,EAAP;AACA;AAED;AACD;AACA;AACA;AACA;AACA;AACA;;;;aACC,mBAAU;AACT,eAAO,KAAKhE,eAAL,CAAqBiE,OAArB,EAAP;AACA;AAED;AACD;AACA;AACA;AACA;AACA;AACA;;;;aACC,qBAAY;AACX,eAAO,IAAP;AACA;AAED;AACD;AACA;AACA;AACA;AACA;AACA;AACA;;;;aACC,kCAAyBnF,WAAzB,EAAgD;AAC/C,aAAKqD,eAAL,CAAqB+B,wBAArB,CAA8CpF,WAA9C;AACA;AAED;AACD;AACA;AACA;AACA;AACA;AACA;AACA;;;;aACC,oCAA2BA,WAA3B,EAAkD;AACjD,aAAKqD,eAAL,CAAqBgC,0BAArB,CAAgDrF,WAAhD;AACA;AAED;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;aACC,2BAAkBC,UAAlB,EAA+C;AAC9C,aAAKqD,cAAL,CAAoBgC,iBAApB,CAAsCrF,UAAtC;AACA;AAED;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;aACC,sBAAaC,gBAAb,EAAoD;AACnD,aAAKoD,cAAL,CAAoBiC,YAApB,CAAiCrF,gBAAjC;AACA;AAED;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;aACC,kBAASC,MAAT,EAA+B;AAC9B,aAAKmD,cAAL,CAAoBkC,QAApB,CAA6BrF,MAA7B;AACA;AAED;AACD;AACA;AACA;AACA;;;;aACC,6BAA4B;AAC3B,eAAQ,KAAKe,eAAL,CAAqBiE,OAArB,EAAD,CAAwCM,iBAAxC,EAAP;AACA;;;;IAtd0BjF,O;AAyd5B;AACA;AACA;AACA;AACA;;;MACMkF,oB;;;;;;;;;;;;;;AACL;AACD;AACA;AACA;AACA;AACA;AACA;AACC,8BAAeC,eAAf,EAAgG;AAC/FA,QAAAA,eAAe,CAACxE,QAAhB,CAAyBC,cAAzB,GAA0CwE,GAAG,CAACC,MAAJ,IAAeD,GAAG,CAACC,MAAJ,CAAWC,SAApE;AACA,YAAMC,aAAa,GAAGJ,eAAe,CAACxE,QAAhB,CAAyBC,cAAzB,GACnB,IAAIN,aAAJ,CAAkB6E,eAAlB,CADmB,GAEnB,IAAI1G,gBAAJ,CAAqB0G,eAArB,CAFH;AAGA,eAAOI,aAAa,CAAC7G,WAAd,CAA0B4D,IAA1B,CAA+B,YAAM;AAC3C;AACC6C,UAAAA,eAAe,CAAC1E,WAAjB,CAAqC+E,gBAArC,GAAwD;AAAA,mBAAMD,aAAN;AAAA,WAAxD;;AACA,iBAAOA,aAAP;AACA,SAJM,CAAP;AAKA;;;;IAlBiCE,c;;SAqBpBP,oB","sourceRoot":".","sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n\nimport { ServiceFactory, Service, ServiceContext } from \"sap/ui/core/service\";\nimport { Container, CrossApplicationNavigation, ShellNavigation, URLParsing } from \"sap/ushell/services\";\nimport { Component } from \"sap/ui/core\";\n\n/**\n * @interface IShellServices\n * @private\n */\nexport interface IShellServices {\n\tinitPromise: Promise<IShellServices>;\n\n\tgetLinks(oArgs: object): Promise<any>;\n\n\ttoExternal(oNavArgumentsArr: Array<object>, oComponent: object): void;\n\n\tgetStartupAppState(oArgs: object): Promise<any>;\n\n\tbackToPreviousApp(): void;\n\n\threfForExternal(oArgs?: object, oComponent?: object, bAsync?: boolean): string;\n\n\tgetAppState(oComponent: Component, sAppStateKey: string): Promise<any>;\n\n\tcreateEmptyAppState(oComponent: Component): object;\n\n\tisNavigationSupported(oNavArgumentsArr: Array<object>, oComponent: object): Promise<any>;\n\n\tisInitialNavigation(): boolean;\n\n\texpandCompactHash(sHashFragment: string): object;\n\n\tparseShellHash(sHash: string): object;\n\n\tsplitHash(sHash: string): object;\n\n\tconstructShellHash(oNewShellHash: object): string;\n\n\tsetDirtyFlag(bDirty: boolean): void;\n\n\tregisterDirtyStateProvider(fnDirtyStateProvider: Function): void;\n\n\tderegisterDirtyStateProvider(fnDirtyStateProvider: Function): void;\n\n\tcreateRenderer(): object;\n\n\tgetUser(): object;\n\n\thasUShell(): boolean;\n\n\tregisterNavigationFilter(fnNavFilter: Function): void;\n\n\tunregisterNavigationFilter(fnNavFilter: Function): void;\n\n\tsetBackNavigation(fnCallBack?: Function): void;\n\n\tsetHierarchy(aHierarchyLevels: Array<object>): void;\n\n\tsetTitle(sTitle: string): void;\n\n\tgetContentDensity(): string;\n}\n\n/**\n * Mock implementation of the ShellService for OpenFE\n *\n * @implements {IShellServices}\n * @private\n */\nclass ShellServiceMock extends Service<ShellServicesSettings> implements IShellServices {\n\tinitPromise!: Promise<any>;\n\tinstanceType!: string;\n\n\tinit() {\n\t\tthis.initPromise = Promise.resolve(this);\n\t\tthis.instanceType = \"mock\";\n\t}\n\n\tgetLinks(oArgs: object) {\n\t\treturn Promise.resolve([]);\n\t}\n\n\tgetLinksWithCache(oArgs: object) {\n\t\treturn Promise.resolve([]);\n\t}\n\n\ttoExternal(oNavArgumentsArr: Array<object>, oComponent: object) {\n\t\treturn;\n\t}\n\n\tgetStartupAppState(oArgs: object) {\n\t\treturn Promise.resolve(null);\n\t}\n\n\tbackToPreviousApp() {\n\t\treturn;\n\t}\n\n\threfForExternal(oArgs?: object, oComponent?: object, bAsync?: boolean) {\n\t\treturn \"\";\n\t}\n\n\tgetAppState(oComponent: object, sAppStateKey: string) {\n\t\treturn Promise.resolve({});\n\t}\n\n\tcreateEmptyAppState(oComponent: object) {\n\t\treturn Promise.resolve({});\n\t}\n\n\tisNavigationSupported(oNavArgumentsArr: Array<object>, oComponent: object) {\n\t\treturn Promise.resolve({});\n\t}\n\n\tisInitialNavigation() {\n\t\treturn false;\n\t}\n\n\texpandCompactHash(sHashFragment: string) {\n\t\treturn Promise.resolve({});\n\t}\n\n\tparseShellHash(sHash: string) {\n\t\treturn {};\n\t}\n\n\tsplitHash(sHash: string) {\n\t\treturn Promise.resolve({});\n\t}\n\n\tconstructShellHash(oNewShellHash: object) {\n\t\treturn \"\";\n\t}\n\n\tsetDirtyFlag(bDirty: boolean) {\n\t\treturn;\n\t}\n\n\tregisterDirtyStateProvider(fnDirtyStateProvider: Function) {\n\t\treturn;\n\t}\n\n\tderegisterDirtyStateProvider(fnDirtyStateProvider: Function) {\n\t\treturn;\n\t}\n\n\tcreateRenderer() {\n\t\treturn {};\n\t}\n\n\tgetUser() {\n\t\treturn {};\n\t}\n\n\thasUShell() {\n\t\treturn false;\n\t}\n\n\tregisterNavigationFilter(fnNavFilter: Function): void {\n\t\treturn;\n\t}\n\n\tunregisterNavigationFilter(fnNavFilter: Function): void {\n\t\treturn;\n\t}\n\n\tsetBackNavigation(fnCallBack?: Function): void {\n\t\treturn;\n\t}\n\n\tsetHierarchy(aHierarchyLevels: Array<object>): void {\n\t\treturn;\n\t}\n\n\tsetTitle(sTitle: string): void {\n\t\treturn;\n\t}\n\n\tgetContentDensity(): string {\n\t\t// in case there is no shell we probably need to look at the classes being defined on the body\n\t\tif (document.body.classList.contains(\"sapUiSizeCozy\")) {\n\t\t\treturn \"cozy\";\n\t\t} else if (document.body.classList.contains(\"sapUiSizeCompact\")) {\n\t\t\treturn \"compact\";\n\t\t} else {\n\t\t\treturn \"\";\n\t\t}\n\t}\n}\n\n/**\n * @typedef ShellServicesSettings\n * @private\n */\nexport type ShellServicesSettings = {\n\tshellContainer?: Container;\n};\n\n/**\n * Wrap a JQuery Promise within a native {Promise}.\n *\n * @template {object} T\n * @param {jQuery.Promise<T>} jqueryPromise The original jquery promise\n * @returns {Promise<T>} A native promise wrapping the same object\n * @private\n */\nfunction wrapJQueryPromise<T>(jqueryPromise: jQuery.Promise): Promise<T> {\n\treturn new Promise((resolve, reject) => {\n\t\t// eslint-disable-next-line promise/catch-or-return\n\t\tjqueryPromise.done(resolve as any).fail(reject);\n\t});\n}\n\n/**\n * Base implementation of the ShellServices\n *\n * @implements {IShellServices}\n * @private\n */\nclass ShellServices extends Service<Required<ShellServicesSettings>> implements IShellServices {\n\tresolveFn: any;\n\trejectFn: any;\n\tinitPromise!: Promise<any>;\n\t// !: means that we know it will be assigned before usage\n\tcrossAppNavService!: CrossApplicationNavigation;\n\turlParsingService!: URLParsing;\n\tshellNavigation!: ShellNavigation;\n\toShellContainer!: Container;\n\tshellUIService!: any;\n\tinstanceType!: string;\n\tlinksCache!: any;\n\tfnFindSemanticObjectsInCache: any;\n\n\tinit() {\n\t\tconst oContext = this.getContext();\n\t\tconst oComponent = oContext.scopeObject as any;\n\t\tthis.oShellContainer = oContext.settings.shellContainer;\n\t\tthis.instanceType = \"real\";\n\t\tthis.linksCache = {};\n\t\tthis.fnFindSemanticObjectsInCache = function(oArgs: any): object {\n\t\t\tconst _oArgs: any = oArgs;\n\t\t\tconst aCachedSemanticObjects = [];\n\t\t\tconst aNonCachedSemanticObjects = [];\n\t\t\tfor (let i = 0; i < _oArgs.length; i++) {\n\t\t\t\tif (!!_oArgs[i][0] && !!_oArgs[i][0].semanticObject) {\n\t\t\t\t\tif (this.linksCache[_oArgs[i][0].semanticObject]) {\n\t\t\t\t\t\taCachedSemanticObjects.push(this.linksCache[_oArgs[i][0].semanticObject].links);\n\t\t\t\t\t\tObject.defineProperty(oArgs[i][0], \"links\", {\n\t\t\t\t\t\t\tvalue: this.linksCache[_oArgs[i][0].semanticObject].links\n\t\t\t\t\t\t});\n\t\t\t\t\t} else {\n\t\t\t\t\t\taNonCachedSemanticObjects.push(_oArgs[i]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn { oldArgs: oArgs, newArgs: aNonCachedSemanticObjects, cachedLinks: aCachedSemanticObjects };\n\t\t};\n\t\tthis.initPromise = new Promise((resolve, reject) => {\n\t\t\tthis.resolveFn = resolve;\n\t\t\tthis.rejectFn = reject;\n\t\t});\n\t\tconst oCrossAppNavServicePromise = this.oShellContainer.getServiceAsync(\"CrossApplicationNavigation\");\n\t\tconst oUrlParsingServicePromise = this.oShellContainer.getServiceAsync(\"URLParsing\");\n\t\tconst oShellNavigationServicePromise = this.oShellContainer.getServiceAsync(\"ShellNavigation\");\n\t\tconst oShellUIServicePromise = oComponent.getService(\"ShellUIService\");\n\t\tPromise.all([oCrossAppNavServicePromise, oUrlParsingServicePromise, oShellNavigationServicePromise, oShellUIServicePromise])\n\t\t\t.then(([oCrossAppNavService, oUrlParsingService, oShellNavigation, oShellUIService]) => {\n\t\t\t\tthis.crossAppNavService = oCrossAppNavService;\n\t\t\t\tthis.urlParsingService = oUrlParsingService;\n\t\t\t\tthis.shellNavigation = oShellNavigation;\n\t\t\t\tthis.shellUIService = oShellUIService;\n\t\t\t\tthis.resolveFn();\n\t\t\t})\n\t\t\t.catch(this.rejectFn);\n\t}\n\n\t/**\n\t * Retrieves the target links configured for a given semantic object & action\n\t * Will retrieve the CrossApplicationNavigation\n\t * service reference call the getLinks method. In case service is not available or any exception\n\t * method throws exception error in console.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} oArgs Check the definition of\n\t * sap.ushell.services.CrossApplicationNavigation=>getLinks arguments\n\t * @returns {Promise} Promise which will be resolved to target links array\n\t */\n\tgetLinks(oArgs: object) {\n\t\treturn new Promise((resolve, reject) => {\n\t\t\t// eslint-disable-next-line promise/catch-or-return\n\t\t\tthis.crossAppNavService\n\t\t\t\t.getLinks(oArgs)\n\t\t\t\t.fail((oError: any) => {\n\t\t\t\t\treject(new Error(oError + \" sap.fe.core.services.NavigationServiceFactory.getLinks\"));\n\t\t\t\t})\n\t\t\t\t.then(resolve);\n\t\t});\n\t}\n\n\t/**\n\t * Retrieves the target links configured for a given semantic object & action in cache\n\t * Will retrieve the CrossApplicationNavigation\n\t * service reference call the getLinks method. In case service is not available or any exception\n\t * method throws exception error in console.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} oArgs Check the definition of\n\t * sap.ushell.services.CrossApplicationNavigation=>getLinks arguments\n\t * @returns {Promise} Promise which will be resolved to target links array\n\t */\n\tgetLinksWithCache(oArgs: object) {\n\t\treturn new Promise((resolve, reject) => {\n\t\t\t// eslint-disable-next-line promise/catch-or-return\n\t\t\tif ((oArgs as Object[]).length === 0) {\n\t\t\t\tresolve([]);\n\t\t\t} else {\n\t\t\t\tlet aLinks;\n\t\t\t\tconst oCacheResults = this.fnFindSemanticObjectsInCache(oArgs);\n\n\t\t\t\tif (oCacheResults.newArgs.length === 0) {\n\t\t\t\t\tresolve(oCacheResults.cachedLinks);\n\t\t\t\t} else {\n\t\t\t\t\t// eslint-disable-next-line promise/catch-or-return\n\t\t\t\t\tthis.crossAppNavService\n\t\t\t\t\t\t.getLinks(oCacheResults.newArgs)\n\t\t\t\t\t\t.fail((oError: any) => {\n\t\t\t\t\t\t\treject(new Error(oError + \" sap.fe.core.services.NavigationServiceFactory.getLinksWithCache\"));\n\t\t\t\t\t\t})\n\t\t\t\t\t\t.then((aLinks: any) => {\n\t\t\t\t\t\t\tif (aLinks.length !== 0) {\n\t\t\t\t\t\t\t\tconst oSemanticObjectsLinks: any = {};\n\n\t\t\t\t\t\t\t\tfor (let i = 0; i < aLinks.length; i++) {\n\t\t\t\t\t\t\t\t\tif (aLinks[i].length > 0 && oCacheResults.newArgs[i][0].links === undefined) {\n\t\t\t\t\t\t\t\t\t\toSemanticObjectsLinks[oCacheResults.newArgs[i][0].semanticObject] = {\n\t\t\t\t\t\t\t\t\t\t\tlinks: aLinks[i]\n\t\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t\t\tthis.linksCache = Object.assign(this.linksCache, oSemanticObjectsLinks);\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tif (oCacheResults.cachedLinks.length === 0) {\n\t\t\t\t\t\t\t\tresolve(aLinks);\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tconst aMergedLinks = [];\n\t\t\t\t\t\t\t\tlet j = 0;\n\n\t\t\t\t\t\t\t\tfor (let k = 0; k < oCacheResults.oldArgs.length; k++) {\n\t\t\t\t\t\t\t\t\tif (j < aLinks.length) {\n\t\t\t\t\t\t\t\t\t\tif (\n\t\t\t\t\t\t\t\t\t\t\taLinks[j].length > 0 &&\n\t\t\t\t\t\t\t\t\t\t\toCacheResults.oldArgs[k][0].semanticObject === oCacheResults.newArgs[j][0].semanticObject\n\t\t\t\t\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t\t\t\t\taMergedLinks.push(aLinks[j]);\n\t\t\t\t\t\t\t\t\t\t\tj++;\n\t\t\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\t\t\taMergedLinks.push(oCacheResults.oldArgs[k][0].links);\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\t\taMergedLinks.push(oCacheResults.oldArgs[k][0].links);\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tresolve(aMergedLinks);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * Will retrieve the ShellContainer.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * sap.ushell.container\n\t * @returns {object} Object with predefined shellContainer methods\n\t */\n\tgetShellContainer() {\n\t\treturn this.oShellContainer;\n\t}\n\n\t/**\n\t * Will call toExternal method of CrossApplicationNavigation service with Navigation Arguments and oComponent.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {Array} oNavArgumentsArr And\n\t * @param {object} oComponent Check the definition of\n\t * sap.ushell.services.CrossApplicationNavigation=>toExternal arguments\n\t * @returns {void}\n\t */\n\ttoExternal(oNavArgumentsArr: Array<object>, oComponent: object): void {\n\t\tthis.crossAppNavService.toExternal(oNavArgumentsArr, oComponent);\n\t}\n\n\t/**\n\t * Retrieves the target startupAppState\n\t * Will check the existance of the ShellContainer and retrieve the CrossApplicationNavigation\n\t * service reference call the getStartupAppState method. In case service is not available or any exception\n\t * method throws exception error in console.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} oArgs Check the definition of\n\t * sap.ushell.services.CrossApplicationNavigation=>getStartupAppState arguments\n\t * @returns {Promise} Promise which will be resolved to Object\n\t */\n\tgetStartupAppState(oArgs: Component) {\n\t\treturn new Promise((resolve, reject) => {\n\t\t\t// JQuery Promise behaves differently\n\t\t\t// eslint-disable-next-line promise/catch-or-return\n\t\t\tthis.crossAppNavService\n\t\t\t\t.getStartupAppState(oArgs)\n\t\t\t\t.fail((oError: any) => {\n\t\t\t\t\treject(new Error(oError + \" sap.fe.core.services.NavigationServiceFactory.getStartupAppState\"));\n\t\t\t\t})\n\t\t\t\t.then(resolve);\n\t\t});\n\t}\n\n\t/**\n\t * Will call backToPreviousApp method of CrossApplicationNavigation service.\n\t *\n\t * @returns {void}\n\t * @private\n\t * @ui5-restricted\n\t */\n\tbackToPreviousApp() {\n\t\treturn this.crossAppNavService.backToPreviousApp();\n\t}\n\n\t/**\n\t * Will call hrefForExternal method of CrossApplicationNavigation service.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} oArgs Check the definition of\n\t * @param {object} oComponent The appComponent\n\t * @param {boolean} bAsync Whether this call should be async or not\n\t * sap.ushell.services.CrossApplicationNavigation=>hrefForExternal arguments\n\t * @returns {string} Promise which will be resolved to string\n\t */\n\threfForExternal(oArgs: object, oComponent?: object, bAsync?: boolean) {\n\t\treturn this.crossAppNavService.hrefForExternal(oArgs, oComponent as object, !!bAsync);\n\t}\n\n\t/**\n\t * Will call getAppState method of CrossApplicationNavigation service with oComponent and oAppStateKey.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} oComponent\n\t * @param {string} sAppStateKey Check the definition of\n\t * sap.ushell.services.CrossApplicationNavigation=>getAppState arguments\n\t * @returns {Promise} Promise which will be resolved to object\n\t */\n\tgetAppState(oComponent: Component, sAppStateKey: string) {\n\t\treturn wrapJQueryPromise(this.crossAppNavService.getAppState(oComponent, sAppStateKey));\n\t}\n\n\t/**\n\t * Will call createEmptyAppState method of CrossApplicationNavigation service with oComponent.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} oComponent Check the definition of\n\t * sap.ushell.services.CrossApplicationNavigation=>createEmptyAppState arguments\n\t * @returns {Promise} Promise which will be resolved to object\n\t */\n\tcreateEmptyAppState(oComponent: Component) {\n\t\treturn this.crossAppNavService.createEmptyAppState(oComponent);\n\t}\n\n\t/**\n\t * Will call isNavigationSupported method of CrossApplicationNavigation service with Navigation Arguments and oComponent.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {Array} oNavArgumentsArr\n\t * @param {object} oComponent Check the definition of\n\t * sap.ushell.services.CrossApplicationNavigation=>isNavigationSupported arguments\n\t * @returns {Promise} Promise which will be resolved to object\n\t */\n\tisNavigationSupported(oNavArgumentsArr: Array<object>, oComponent: object) {\n\t\treturn wrapJQueryPromise(this.crossAppNavService.isNavigationSupported(oNavArgumentsArr, oComponent));\n\t}\n\n\t/**\n\t * Will call isInitialNavigation method of CrossApplicationNavigation service.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @returns {Promise} Promise which will be resolved to boolean\n\t */\n\tisInitialNavigation() {\n\t\treturn this.crossAppNavService.isInitialNavigation();\n\t}\n\n\t/**\n\t * Will call expandCompactHash method of CrossApplicationNavigation service.\n\t *\n\t * @param {string} sHashFragment An (internal format) shell hash\n\t * @returns {Promise} A promise the success handler of the resolve promise get an expanded shell hash as first argument\n\t * @private\n\t * @ui5-restricted\n\t */\n\texpandCompactHash(sHashFragment: string) {\n\t\treturn this.crossAppNavService.expandCompactHash(sHashFragment);\n\t}\n\n\t/**\n\t * Will call parseShellHash method of URLParsing service with given sHash.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {string} sHash Check the definition of\n\t * sap.ushell.services.URLParsing=>parseShellHash arguments\n\t * @returns {object}\n\t */\n\tparseShellHash(sHash: string) {\n\t\treturn this.urlParsingService.parseShellHash(sHash);\n\t}\n\n\t/**\n\t * Will call splitHash method of URLParsing service with given sHash.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {string} sHash Check the definition of\n\t * sap.ushell.services.URLParsing=>splitHash arguments\n\t * @returns {Promise} Promise which will be resolved to object\n\t */\n\tsplitHash(sHash: string) {\n\t\treturn this.urlParsingService.splitHash(sHash);\n\t}\n\n\t/**\n\t * Will call constructShellHash method of URLParsing service with given sHash.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {object} oNewShellHash Check the definition of\n\t * sap.ushell.services.URLParsing=>constructShellHash arguments\n\t * @returns {string} Shell Hash string\n\t */\n\tconstructShellHash(oNewShellHash: object) {\n\t\treturn this.urlParsingService.constructShellHash(oNewShellHash);\n\t}\n\n\t/**\n\t * Will call setDirtyFlag method with given dirty state.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {boolean} bDirty Check the definition of sap.ushell.Container.setDirtyFlag arguments\n\t */\n\tsetDirtyFlag(bDirty: boolean) {\n\t\tthis.oShellContainer.setDirtyFlag(bDirty);\n\t}\n\n\t/**\n\t * Will call registerDirtyStateProvider method with given dirty state provider callback method.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {Function} fnDirtyStateProvider Check the definition of sap.ushell.Container.registerDirtyStateProvider arguments\n\t */\n\tregisterDirtyStateProvider(fnDirtyStateProvider: Function) {\n\t\tthis.oShellContainer.registerDirtyStateProvider(fnDirtyStateProvider);\n\t}\n\n\t/**\n\t * Will call deregisterDirtyStateProvider method with given dirty state provider callback method.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @param {Function} fnDirtyStateProvider Check the definition of sap.ushell.Container.deregisterDirtyStateProvider arguments\n\t */\n\tderegisterDirtyStateProvider(fnDirtyStateProvider: Function) {\n\t\tthis.oShellContainer.deregisterDirtyStateProvider(fnDirtyStateProvider);\n\t}\n\n\t/**\n\t * Will call createRenderer method of ushell container.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @returns {object} Returns renderer object\n\t */\n\tcreateRenderer() {\n\t\treturn this.oShellContainer.createRenderer();\n\t}\n\n\t/**\n\t * Will call getUser method of ushell container.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @returns {object} Returns User object\n\t */\n\tgetUser() {\n\t\treturn this.oShellContainer.getUser();\n\t}\n\n\t/**\n\t * Will check if ushell container is available or not.\n\t *\n\t * @private\n\t * @ui5-restricted\n\t * @returns {boolean} Returns true\n\t */\n\thasUShell() {\n\t\treturn true;\n\t}\n\n\t/**\n\t * Will call registerNavigationFilter method of shellNavigation.\n\t *\n\t * @param {Function} fnNavFilter The filter function to register\n\t * @returns {void}\n\t * @private\n\t * @ui5-restricted\n\t */\n\tregisterNavigationFilter(fnNavFilter: Function) {\n\t\tthis.shellNavigation.registerNavigationFilter(fnNavFilter);\n\t}\n\n\t/**\n\t * Will call unregisterNavigationFilter method of shellNavigation.\n\t *\n\t * @param {Function} fnNavFilter The filter function to unregister\n\t * @returns {void}\n\t * @private\n\t * @ui5-restricted\n\t */\n\tunregisterNavigationFilter(fnNavFilter: Function) {\n\t\tthis.shellNavigation.unregisterNavigationFilter(fnNavFilter);\n\t}\n\n\t/**\n\t * Will call setBackNavigation method of ShellUIService\n\t * that displays the back button in the shell header.\n\t *\n\t * @param {Function} [fnCallBack] A callback function called when the button is clicked in the UI.\n\t * @returns {void}\n\t * @private\n\t * @ui5-restricted\n\t */\n\tsetBackNavigation(fnCallBack?: Function): void {\n\t\tthis.shellUIService.setBackNavigation(fnCallBack);\n\t}\n\n\t/**\n\t * Will call setHierarchy method of ShellUIService\n\t * that displays the given hierarchy in the shell header.\n\t *\n\t * @param {object[]} [aHierarchyLevels] An array representing hierarchies of the currently displayed app.\n\t * @returns {void}\n\t * @private\n\t * @ui5-restricted\n\t */\n\tsetHierarchy(aHierarchyLevels: Array<object>): void {\n\t\tthis.shellUIService.setHierarchy(aHierarchyLevels);\n\t}\n\n\t/**\n\t * Will call setTitle method of ShellUIService\n\t * that displays the given title in the shell header.\n\t *\n\t * @param {string} [sTitle] The new title. The default title is set if this argument is not given.\n\t * @returns {void}\n\t * @private\n\t * @ui5-restricted\n\t */\n\tsetTitle(sTitle: string): void {\n\t\tthis.shellUIService.setTitle(sTitle);\n\t}\n\n\t/**\n\t * Retrieves the currently defined content density.\n\t *\n\t * @returns {string} The content density value\n\t */\n\tgetContentDensity(): string {\n\t\treturn (this.oShellContainer.getUser() as any).getContentDensity();\n\t}\n}\n\n/**\n * Service Factory for the ShellServices\n *\n * @private\n */\nclass ShellServicesFactory extends ServiceFactory<ShellServicesSettings> {\n\t/**\n\t * Creates either a standard or a mock Shell service depending on the configuration.\n\t *\n\t * @param {ServiceContext<ShellServicesSettings>} oServiceContext The shellservice context\n\t * @returns {Promise<IShellServices>} A promise for a shell service implementation\n\t * @see ServiceFactory#createInstance\n\t */\n\tcreateInstance(oServiceContext: ServiceContext<ShellServicesSettings>): Promise<IShellServices> {\n\t\toServiceContext.settings.shellContainer = sap.ushell && (sap.ushell.Container as Container);\n\t\tconst oShellService = oServiceContext.settings.shellContainer\n\t\t\t? new ShellServices(oServiceContext as ServiceContext<Required<ShellServicesSettings>>)\n\t\t\t: new ShellServiceMock(oServiceContext);\n\t\treturn oShellService.initPromise.then(() => {\n\t\t\t// Enrich the appComponent with this method\n\t\t\t(oServiceContext.scopeObject as any).getShellServices = () => oShellService;\n\t\t\treturn oShellService;\n\t\t});\n\t}\n}\n\nexport default ShellServicesFactory;\n"]}