@sapui5/sap.ushell 1.142.0 → 1.143.0

package/src/main/js/sap/ushell/utils/UrlParsing.js

@@ -15,6 +15,7 @@
 sap.ui.define([
     "sap/ui/thirdparty/URI",
     "sap/base/Log",
+    "sap/base/util/deepClone",
     "sap/base/util/deepEqual",
     "sap/base/util/merge",
     "sap/ushell/TechnicalParameters",
@@ -22,6 +23,7 @@ sap.ui.define([
 ], (
     URI,
     Log,
+    deepClone,
     deepEqual,
     merge,
     TechnicalParameters,
@@ -100,7 +102,6 @@ sap.ui.define([
         if (match) {
             return match[1];
         }
-        return undefined;
     };
 
     /**
@@ -117,7 +118,6 @@ sap.ui.define([
         if (match) {
             return match[1];
         }
-        return undefined;
     };
 
     /**
@@ -192,11 +192,11 @@ sap.ui.define([
             }
         }
         // sUrl is to be processed by our launchpad
-        const sHash = UrlParsing.getHash(sUrl);
+        const sHash = this.getHash(sUrl);
         if (!sHash) {
             return false;
         }
-        const oParsedHash = UrlParsing.parseShellHash(sHash);
+        const oParsedHash = this.parseShellHash(sHash);
         if (oParsedHash && oParsedHash.semanticObject && oParsedHash.action) {
             return true;
         }
@@ -232,47 +232,6 @@ sap.ui.define([
         }
     };
 
-    /**
-     * Combines members of a JavaScript object into a parameter string.
-     * Parameters are ordered in an arbitrary manner which might change.
-     *
-     * @param {object} parameters The parameter object, e.g. <code>{ ABC: [1, "1 2"], DEF: ["4"] }</code>.
-     * @param {string} delimiter The parameter delimiter. Default is "&".
-     * @param {string} assign The parameter assignment. Default is "=".
-     * @returns {string} The result parameter string, e.g. <code>ABC=1&ABC=1%202&DEF=4</code>.
-     *   The result is *not* prefixed with a "?". Parameter values are URI encoded.
-     * @since 1.94.0
-     * @private
-     */
-    function _urlParametersToString (parameters, delimiter, assign) {
-        let shellPart = "";
-
-        delimiter = delimiter || "&";
-        assign = assign || "=";
-
-        let first = "";
-        const lst = [];
-        for (const a in parameters) {
-            if (parameters.hasOwnProperty(a)) {
-                lst.push(a);
-            }
-        }
-        lst.sort();
-        for (let k = 0; k < lst.length; k = k + 1) {
-            const a = lst[k];
-            if (Array.isArray(parameters[a])) {
-                for (let i = 0; i < parameters[a].length; i = i + 1) {
-                    shellPart += first + encodeURIComponent(a) + assign + encodeURIComponent(parameters[a][i]);
-                    first = delimiter;
-                }
-            } else {
-                shellPart += first + encodeURIComponent(a) + assign + encodeURIComponent(parameters[a]);
-                first = delimiter;
-            }
-        }
-        return shellPart;
-    }
-
     /**
      * combine members of a javascript object into a parameter string,
      * note that parameters are ordered in an arbitrary manner which is subject to change
@@ -284,7 +243,7 @@ sap.ui.define([
      * @protected
      */
     UrlParsing.paramsToString = function (oParams) {
-        return _urlParametersToString(oParams);
+        return this.urlParametersToString(oParams);
     };
 
     /**
@@ -312,33 +271,60 @@ sap.ui.define([
     };
 
     /**
-     * Internal function
+     * Combines members of a JavaScript object into a parameter string.
+     * Parameters are ordered in an arbitrary manner which might change.
      *
-     * @param {object} oParams parameter object
-     * @param {string} sDelimiter string to use as parameter delimiter (e.g., "&")
-     * @param {string} sAssign string to use for parameter assignment (e.g., "=")
-     * @returns {string} the result parameters
+     * @param {object} oParameters The parameter object, e.g. <code>{ ABC: [1, "1 2"], DEF: ["4"] }</code>.
+     * @param {string} sDelimiter The parameter delimiter. Default is "&".
+     * @param {string} sAssign The parameter assignment. Default is "=".
+     * @returns {string} The result parameter string, e.g. <code>ABC=1&ABC=1%202&DEF=4</code>.
+     *   The result is *not* prefixed with a "?". Parameter values are URI encoded.
      * @since 1.94.0
      * @private
      */
-    UrlParsing.urlParametersToString = function (oParams, sDelimiter, sAssign) {
-        return _urlParametersToString(oParams, sDelimiter, sAssign);
+    UrlParsing.urlParametersToString = function (oParameters, sDelimiter, sAssign) {
+        let sShellPart = "";
+
+        sDelimiter = sDelimiter || "&";
+        sAssign = sAssign || "=";
+
+        let sFirst = "";
+        const aParameterKeys = [];
+        for (const sKey in oParameters) {
+            if (oParameters.hasOwnProperty(sKey)) {
+                aParameterKeys.push(sKey);
+            }
+        }
+        aParameterKeys.sort();
+        for (let k = 0; k < aParameterKeys.length; k = k + 1) {
+            const sKey = aParameterKeys[k];
+            if (Array.isArray(oParameters[sKey])) {
+                for (let i = 0; i < oParameters[sKey].length; i = i + 1) {
+                    sShellPart += sFirst + encodeURIComponent(sKey) + sAssign + encodeURIComponent(oParameters[sKey][i]);
+                    sFirst = sDelimiter;
+                }
+            } else {
+                sShellPart += sFirst + encodeURIComponent(sKey) + sAssign + encodeURIComponent(oParameters[sKey]);
+                sFirst = sDelimiter;
+            }
+        }
+        return sShellPart;
     };
 
     /**
      * adds parameter to a url
      * which can be relative or a hash
-     * @param {string} sUrlorHash "url" which can be relative or a hash
+     * @param {string} sUrlOrHash "url" which can be relative or a hash
      * @param {object} oUrlParams Url parameter
      * @returns {string} new url with the parameters
      * @since 1.131.0
      *
      */
-    UrlParsing.addParamsToUrl = function (sUrlorHash, oUrlParams) {
-        const oUri = new URI(sUrlorHash);
+    UrlParsing.addParamsToUrl = function (sUrlOrHash, oUrlParams) {
+        const oUri = new URI(sUrlOrHash);
         Object.keys(oUrlParams)
-            .forEach((key)=>{
-                oUri.addSearch(key, oUrlParams[key]);
+            .forEach((sKey)=>{
+                oUri.addSearch(sKey, oUrlParams[sKey]);
             });
         return oUri.toString();
     };
@@ -346,29 +332,29 @@ sap.ui.define([
     /**
      * add parameters of the shell specific part to the URL or hash
      * makes sure they are before the app specific hash
-     * @param {string} sUrlorHash Url can be relative or a hash
+     * @param {string} sUrlOrHash Url can be relative or a hash
      * @param {object} oShellParams Shell parameters
      * @returns {string} url with added parameters
      *
      * @since 1.131.0
      *
      */
-    UrlParsing.addShellParamsToURL = function (sUrlorHash, oShellParams) {
-        const oURI = new URI(sUrlorHash);
+    UrlParsing.addShellParamsToURL = function (sUrlOrHash, oShellParams) {
+        const oURI = new URI(sUrlOrHash);
 
         // split hash into shell part and app specific route
         const sHashPart = oURI.hash();
         const sBeforeHashPart = oURI.toString().replace(sHashPart, "");
 
         // merge the parameters
-        const oParseHash = UrlParsing.parseShellHash(sHashPart) || {};
+        const oParseHash = this.parseShellHash(sHashPart) || {};
         Object.assign(oParseHash.params, oShellParams.params);
 
         // now put it back together
 
         // new hash
         // construct Shell Hash
-        const sNewHash = `#${UrlParsing.constructShellHash(oParseHash)}`;
+        const sNewHash = `#${this.constructShellHash(oParseHash)}`;
 
         return sBeforeHashPart + sNewHash;
     };
@@ -379,6 +365,7 @@ sap.ui.define([
      * @param {string} sHash Hash part of a shell compliant URL
      *   <code>#SO-Action~Context?P1=a&P2=x&/route?RPV=1</code> the hash part of an URL, <br/>
      *   e.g. <code>"#Object-name~AFE2==?PV1=PV2&PV4=V5&/display/detail/7?UU=HH</code>
+     * @param {boolean} [bReturnEmpty=false] Return an empty parsed hash object instead of undefined
      * @returns {object} <code>undefined</code> if not a parseable hash<br/>
      * <pre>
      *   {
@@ -393,13 +380,16 @@ sap.ui.define([
      * @since 1.94.0
      * @protected
      */
-    UrlParsing.parseShellHash = function (sHash) {
+    UrlParsing.parseShellHash = function (sHash, bReturnEmpty) {
         const re = reValidShellPart;
         if (!sHash) {
-            return undefined;
+            if (bReturnEmpty) {
+                return this.getEmptyParsedHash();
+            }
+            return;
         }
         // split shell-hash and app-specific parts first
-        const oSplitHash = UrlParsing.splitHash(sHash);
+        const oSplitHash = this.splitHash(sHash);
 
         const match = re.exec(oSplitHash.shellPart);
         if (match) {
@@ -407,12 +397,12 @@ sap.ui.define([
             const sAction = match[3];
             const sContext = match[5];
             const sParams = match[6];
-            const pm = UrlParsing.parseParameters(sParams);
+            const oParsedParams = this.parseParameters(sParams);
             return {
                 semanticObject: sSemanticObject,
                 action: sAction,
                 contextRaw: sContext,
-                params: pm,
+                params: oParsedParams,
                 appSpecificRoute: oSplitHash.appSpecificRoute
             };
         }
@@ -425,7 +415,27 @@ sap.ui.define([
                 appSpecificRoute: oSplitHash.appSpecificRoute
             };
         }
-        return undefined;
+        if (bReturnEmpty) {
+            return this.getEmptyParsedHash();
+        }
+    };
+
+    /**
+     * Returns an empty parsed hash.
+     * This is useful to have a consistent empty object instead of "undefined"
+     * @returns {object} empty parsed hash
+     *
+     * @since 1.142.0
+     * @private
+     */
+    UrlParsing.getEmptyParsedHash = function () {
+        return {
+            semanticObject: undefined,
+            action: undefined,
+            contextRaw: undefined,
+            params: {},
+            appSpecificRoute: undefined
+        };
     };
 
     /**
@@ -436,11 +446,12 @@ sap.ui.define([
      * @since 1.94.0
      * @private
      */
-    UrlParsing.privstripLeadingHash = function (sHash) {
-        if (sHash[0] === "#") {
-            return sHash.substring(1);
+    UrlParsing.stripLeadingHash = function (sHash) {
+        if (!sHash.startsWith("#")) {
+            return sHash;
         }
-        return sHash;
+
+        return sHash.substring(1);
     };
 
     /**
@@ -453,32 +464,13 @@ sap.ui.define([
      */
     UrlParsing.ensureLeadingHash = function (sHash) {
         if (!sHash) {
-            sHash = "#";
-        } else if (sHash.charAt(0) !== "#") {
-            sHash = `#${sHash}`;
+            return "#";
         }
-        return sHash;
-    };
-
-    /**
-     * Reduces a hash to the semantic object and action part.
-     * Does not include the leading '#'.
-     * Returns empty string if the hash is not parseable.
-     *
-     * @param {string} sHash Shell hash.
-     * @returns {string} The basic hash.
-     *
-     * @since 1.129.0
-     * @private
-     */
-    UrlParsing.getBasicHash = function (sHash) {
-        const oShellHash = this.parseShellHash(sHash);
-
-        if (!oShellHash) {
-            return "";
+        if (sHash.startsWith("#")) {
+            return sHash;
         }
 
-        return `${oShellHash.semanticObject}-${oShellHash.action}`;
+        return `#${sHash}`;
     };
 
     /**
@@ -524,21 +516,90 @@ sap.ui.define([
         return {};
     };
 
-    function appendIf (sUrl, app) {
-        if (app) {
-            return sUrl + app;
+    function appendIf (sUrl, sPostfix) {
+        if (sPostfix) {
+            return sUrl + sPostfix;
+        }
+        return sUrl;
+    }
+
+    function prependIf (sPrefix, sUrl) {
+        if (sPrefix) {
+            return sPrefix + sUrl;
         }
         return sUrl;
     }
 
+    /**
+     * Harmonizes the shell hash by ensuring it has all required properties.
+     * The result is compliant with {@link #parseShellHash}.
+     * Clones the input object.
+     *
+     * @param {sap.ushell.services.URLParsing.ShellHash} oShellHash The shell hash to harmonize
+     * @returns {sap.ushell.services.URLParsing.DecomposedHash} The hash in the decomposed format.
+     *
+     * @since 1.142.0
+     * @private
+     */
+    UrlParsing._harmonizeShellHash = function (oShellHash) {
+        if (!oShellHash) {
+            return this.getEmptyParsedHash();
+        }
+        const oShellHashClone = deepClone(oShellHash);
+
+        // map target to decomposed hash properties
+        if (oShellHash.target) {
+            if (typeof oShellHash.target.shellHash === "string") {
+                const oParsedHash = this.parseShellHash(
+                    appendIf(
+                        oShellHash.target.shellHash,
+                        oShellHash.appSpecificRoute
+                    )
+                );
+                return oParsedHash || this.getEmptyParsedHash();
+            }
+
+            oShellHashClone.semanticObject = oShellHash.target.semanticObject;
+            oShellHashClone.action = oShellHash.target.action;
+            oShellHashClone.contextRaw = oShellHash.target.contextRaw;
+        }
+
+        // ensure params values are arrays
+        if (oShellHashClone.params) {
+            for (const sKey in oShellHashClone.params) {
+                const vValue = oShellHashClone.params[sKey];
+                if (!Array.isArray(vValue)) {
+                    oShellHashClone.params[sKey] = [vValue];
+                }
+            }
+        } else {
+            oShellHashClone.params = {};
+        }
+
+        if (oShellHashClone.appStateKey) {
+            oShellHashClone.params["sap-xapp-state"] = [oShellHashClone.appStateKey];
+        }
+
+        // strip unallowed properties
+        const aAllowedProperties = [
+            "semanticObject",
+            "action",
+            "contextRaw",
+            "params",
+            "appSpecificRoute"
+        ];
+        for (const sKey in oShellHashClone) {
+            if (!aAllowedProperties.includes(sKey)) {
+                delete oShellHashClone[sKey];
+            }
+        }
+
+        return oShellHashClone;
+    };
+
     /**
      * compose a shell Hash from it's respective parts
      * Note that it also may append an app specific route !
-     *
-     * @returns {string} the hash part of an URL, e.g. <code>"Object-name~AFE2==?PV1=PV2&PV4=V5&/display/detail/7?UU=HH</code>
-     *   returns "" for an undefined object
-     * @param {object} oShellHash The action must be a valid action, it may not contain "?" or directly a parameter string
-     *   <code>undefined</code> if not a parseable hash
      * <pre>
      *   {
      *     target: {
@@ -551,67 +612,123 @@ sap.ui.define([
      *     appSpecificRoute: string
      *   }
      * </pre>
-     *   xor
-     *   <code>{ target: { shellHash } }</code>
-     *   Note: in general it is preferred to add an appStateKey directly to the params object
+     * <code>{ target: { shellHash } }</code>
+     * Note: in general it is preferred to add an appStateKey directly to the params object
+     *
+     * @param {sap.ushell.services.URLParsing.ShellHash} oShellHash
+     *   The action must be a valid action, it may not contain "?" or directly a parameter string
+     * @param {boolean} [bPrefixWithHash=false] if true, the result is prefixed with a leading #
+     * @returns {string} the hash part of an URL, e.g. <code>"Object-name~AFE2==?PV1=PV2&PV4=V5&/display/detail/7?UU=HH</code>
+     *   returns "" for an <code>undefined</code> object
+     *
      * @since 1.94.0
      * @protected
      */
-    UrlParsing.constructShellHash = function (oShellHash) {
-        let shellPart;
-        if (!oShellHash) {
-            return "";
-        }
-        // align lack of target
-        if (!oShellHash.target) {
-            oShellHash.target = {};
-            oShellHash.target.semanticObject = oShellHash.semanticObject;
-            oShellHash.target.action = oShellHash.action;
-            oShellHash.target.contextRaw = oShellHash.contextRaw;
-        }
-        if (oShellHash.target.shellHash || oShellHash.target.shellHash === "") {
-            const result = UrlParsing.privstripLeadingHash(oShellHash.target.shellHash);
-            return appendIf(result, oShellHash.appSpecificRoute);
+    UrlParsing.constructShellHash = function (oShellHash, bPrefixWithHash) {
+        const oParsedHash = this._harmonizeShellHash(oShellHash);
+
+        if (!oParsedHash.semanticObject || !oParsedHash.action) {
+            return prependIf(
+                bPrefixWithHash ? "#" : "",
+                appendIf("", oParsedHash.appSpecificRoute)
+            );
         }
 
-        if (oShellHash.target.semanticObject && oShellHash.target.action) {
-            shellPart = `${oShellHash.target.semanticObject}-${oShellHash.target.action.replace(/[?].*/, "")}`;
-        } else {
-            return appendIf("", oShellHash.appSpecificRoute);
+        let sConstructedHash = `${oParsedHash.semanticObject}-${oParsedHash.action.replace(/[?].*/, "")}`;
+        if (oParsedHash.contextRaw) {
+            sConstructedHash += `~${oParsedHash.contextRaw}`;
         }
 
-        if (oShellHash.target.contextRaw) {
-            shellPart += `~${oShellHash.target.contextRaw}`;
-        }
-        let first = "?";
-        const lst = [];
-        for (const a in oShellHash.params) {
-            if (oShellHash.params.hasOwnProperty(a)) {
-                lst.push(a);
+        let sParamPrefix = "?";
+        const aParameterKeys = Object.keys(oParsedHash.params).sort();
+        for (const sParamKey of aParameterKeys) {
+            const aParamValues = oParsedHash.params[sParamKey];
+            if (aParamValues.length > 1) {
+                Log.error("Array startup parameters violate the designed intent of the Unified Shell Intent, use only single-valued parameters!");
             }
-        }
-        const paramsCopy = (oShellHash.params && JSON.parse(JSON.stringify(oShellHash.params))) || {};
-        if (oShellHash.appStateKey) {
-            lst.push("sap-xapp-state");
-            paramsCopy["sap-xapp-state"] = oShellHash.appStateKey;
-        }
-        lst.sort();
-        for (let k = 0; k < lst.length; k = k + 1) {
-            const a = lst[k];
-            if (Array.isArray(paramsCopy[a])) {
-                if (paramsCopy[a].length > 1) {
-                    Log.error("Array startup parameters violate the designed intent of the Unified Shell Intent, use only single-valued parameters!");
-                }
-                for (let i = 0; i < paramsCopy[a].length; i = i + 1) {
-                    shellPart += `${first + encodeURIComponent(a)}=${encodeURIComponent(paramsCopy[a][i])}`;
-                    first = "&";
-                }
-            } else {
-                shellPart += `${first + encodeURIComponent(a)}=${encodeURIComponent(paramsCopy[a])}`;
-                first = "&";
+            for (const sParamValue of aParamValues) {
+                sConstructedHash += `${sParamPrefix + encodeURIComponent(sParamKey)}=${encodeURIComponent(sParamValue)}`;
+                sParamPrefix = "&";
             }
         }
-        return appendIf(shellPart, oShellHash.appSpecificRoute);
+
+        return prependIf(
+            bPrefixWithHash ? "#" : "",
+            appendIf(sConstructedHash, oParsedHash.appSpecificRoute)
+        );
+    };
+
+    /**
+     * Calculates the stable intent part of the hash
+     *
+     * Remark: It also sorts the parameters and their values. This can change the interpretation of the hash.
+     * Therefore, the stable hash should only be used for comparison or id generation, not for navigation.
+     *
+     * @param {sap.ushell.services.URLParsing.ShellHash} oShellHash The parsed shell hash
+     * @param {boolean} [bPrefixWithHash=false] if true, the result is prefixed with a leading #
+     * @returns {string} the stable intent part of the hash
+     *
+     * @since 1.135.0
+     * @private
+     */
+    UrlParsing.constructStableHash = function (oShellHash, bPrefixWithHash) {
+        const oParsedHash = this._harmonizeShellHash(oShellHash);
+        const oParamsWithoutTechnicalParameters = this._removeNonIntentParameters(oParsedHash.params);
+        // stabilize the "order" of the parameters and values to make the hash comparison stable
+        const oSortedParams = Object.keys(oParamsWithoutTechnicalParameters)
+            .sort()
+            .reduce((oResult, sKey) => {
+                const aValue = oParamsWithoutTechnicalParameters[sKey];
+
+                aValue.sort();
+                oResult[sKey] = aValue;
+                return oResult;
+            }, {});
+
+        return this.constructShellHash({
+            semanticObject: oParsedHash.semanticObject,
+            action: oParsedHash.action,
+            contextRaw: oParsedHash.contextRaw,
+            params: oSortedParams
+            // ignore appSpecificRoute
+        }, bPrefixWithHash);
+    };
+
+    /**
+     * Reduces a hash to the semantic object and action part.
+     *
+     * @param {string} sShellHash The shell hash, with or without the leading #
+     * @param {boolean} [bPrefixWithHash=false] if true, the result is prefixed with a leading #
+     * @returns {string} The basic hash.
+     *
+     * @since 1.129.0
+     * @private
+     */
+    UrlParsing.getBasicHash = function (sShellHash, bPrefixWithHash) {
+        const oParsedHash = this.parseShellHash(sShellHash) || this.getEmptyParsedHash();
+        return this.constructBasicHash(oParsedHash, bPrefixWithHash);
+    };
+
+    /**
+     * Reduces a hash to the semantic object and action part.
+     *
+     * @param {sap.ushell.services.URLParsing.ShellHash} oShellHash The parsed shell hash
+     * @param {boolean} [bPrefixWithHash=false] if true, the result is prefixed with a leading #
+     * @returns {string} The basic hash.
+     *
+     * @since 1.129.0
+     * @private
+     */
+    UrlParsing.constructBasicHash = function (oShellHash, bPrefixWithHash) {
+        const oParsedHash = this._harmonizeShellHash(oShellHash);
+
+        return this.constructShellHash({
+            semanticObject: oParsedHash.semanticObject,
+            action: oParsedHash.action
+            // ignore contextRaw
+            // ignore params
+            // ignore appSpecificRoute
+        }, bPrefixWithHash);
     };
 
     /**
@@ -625,12 +742,27 @@ sap.ui.define([
      * @private
      */
     UrlParsing.compareHashes = function (sHash1, sHash2) {
-        const oNewHash = this.parseShellHash(sHash1) || {};
-        const oOldHash = this.parseShellHash(sHash2) || {};
+        const oHash1 = this.parseShellHash(sHash1) || {};
+        const oHash2 = this.parseShellHash(sHash2) || {};
+
+        return this.compareParsedHashes(oHash1, oHash2);
+    };
+
+    /**
+     * Calculates the similarities of the hashes
+     *
+     * @param {sap.ushell.services.URLParsing.DecomposedHash} oHash1 The first hash
+     * @param {sap.ushell.services.URLParsing.DecomposedHash} oHash2 The second hash
+     * @returns {sap.ushell.utils.URLParsing.HashComparison} A object describing the similarities
+     *
+     * @since 1.142.0
+     * @private
+     */
+    UrlParsing.compareParsedHashes = function (oHash1, oHash2) {
         return {
-            sameIntent: this.haveSameIntent(oNewHash, oOldHash),
-            sameParameters: this.haveSameIntentParameters(oNewHash, oOldHash),
-            sameAppSpecificRoute: oNewHash.appSpecificRoute === oOldHash.appSpecificRoute
+            sameIntent: this.haveSameIntent(oHash1, oHash2),
+            sameParameters: this.haveSameIntentParameters(oHash1, oHash2),
+            sameAppSpecificRoute: oHash1.appSpecificRoute === oHash2.appSpecificRoute
         };
     };
 
@@ -638,8 +770,8 @@ sap.ui.define([
      * Determines whether two hash fragments have the same intent during an
      * app-to-app navigation.
      *
-     * @param {sap.ushell.services.URLParsing.DecomposedHash} oHash1 The first hash split by parseShellHash
-     * @param {sap.ushell.services.URLParsing.DecomposedHash} oHash2 The second hash split by parseShellHash
+     * @param {sap.ushell.services.URLParsing.DecomposedHash} oParsedHash1 The first hash split by parseShellHash
+     * @param {sap.ushell.services.URLParsing.DecomposedHash} oParsedHash2 The second hash split by parseShellHash
      *
      * @returns {boolean}
      *   Whether two hash fragments have the same semantic object and action
@@ -648,68 +780,35 @@ sap.ui.define([
      * @since 1.128.0
      * @private
      */
-    UrlParsing.haveSameIntent = function (oHash1, oHash2) {
-        oHash1 = oHash1 || {};
-        oHash2 = oHash2 || {};
-        return oHash1.semanticObject === oHash2.semanticObject &&
-            oHash1.action === oHash2.action &&
-            oHash1.contextRaw === oHash2.contextRaw;
+    UrlParsing.haveSameIntent = function (oParsedHash1, oParsedHash2) {
+        oParsedHash1 = oParsedHash1 || {};
+        oParsedHash2 = oParsedHash2 || {};
+        return oParsedHash1.semanticObject === oParsedHash2.semanticObject
+            && oParsedHash1.action === oParsedHash2.action
+            && oParsedHash1.contextRaw === oParsedHash2.contextRaw;
     };
 
     /**
      * Determines whether two sets of parameters have the same intent parameters.
      *
-     * @param {sap.ushell.services.URLParsing.DecomposedHash} oHash1 The first hash split by parseShellHash
-     * @param {sap.ushell.services.URLParsing.DecomposedHash} oHash2 The second hash split by parseShellHash
+     * @param {sap.ushell.services.URLParsing.DecomposedHash} oParsedHash1 The first hash split by parseShellHash
+     * @param {sap.ushell.services.URLParsing.DecomposedHash} oParsedHash2 The second hash split by parseShellHash
      * @returns {boolean} Whether the two given set of parameters have the same intent parameters.
      *
      * @since 1.128.0
      * @private
      */
-    UrlParsing.haveSameIntentParameters = function (oHash1, oHash2) {
-        oHash1 = oHash1 || {};
-        oHash2 = oHash2 || {};
-        const oParams1Copy = merge({}, oHash1.params);
-        const oParams2Copy = merge({}, oHash2.params);
+    UrlParsing.haveSameIntentParameters = function (oParsedHash1, oParsedHash2) {
+        oParsedHash1 = oParsedHash1 || {};
+        oParsedHash2 = oParsedHash2 || {};
+        const oParams1Copy = merge({}, oParsedHash1.params);
+        const oParams2Copy = merge({}, oParsedHash2.params);
         return !this._parametersChanged(
             this._removeNonIntentParameters(oParams1Copy),
             this._removeNonIntentParameters(oParams2Copy)
         );
     };
 
-    /**
-     * Calculates the stable intent part of the hash
-     * @param {string} sHash Hash part of a shell compliant URL
-     *   <code>#SO-Action~Context?P1=a&P2=x&/route?RPV=1</code> the hash part of an URL, <br/>
-     *   e.g. <code>"#Object-name~AFE2==?PV1=PV2&PV4=V5&/display/detail/7?UU=HH</code>
-     * @returns {string} the stable intent part of the hash
-     *
-     * @since 1.135.0
-     * @private
-     */
-    UrlParsing.getStableIntent = function (sHash) {
-        const oHash = this.parseShellHash(sHash) || {};
-        const oParamsWithoutTechnicalParameters = this._removeNonIntentParameters(oHash.params);
-        // stabilize the "order" of the parameters and values to make the hash comparison stable
-        const oSortedParams = Object.keys(oParamsWithoutTechnicalParameters)
-            .sort()
-            .reduce((oResult, sKey) => {
-                const aValue = oParamsWithoutTechnicalParameters[sKey];
-                aValue.sort();
-                oResult[sKey] = aValue;
-                return oResult;
-            }, {});
-        return this.constructShellHash({
-            target: {
-                semanticObject: oHash.semanticObject,
-                action: oHash.action,
-                contextRaw: oHash.contextRaw
-            },
-            params: oSortedParams
-            // ignore appSpecificRoute
-        });
-    };
-
     /**
      * Removes all technical parameters from the hash parameters that are not intent parameters
      * and returns the new hash parameters
@@ -750,5 +849,33 @@ sap.ui.define([
         return !deepEqual(oNewParameters, oOldParameters);
     };
 
+    /**
+     * Checks whether the given parsed hash represents the root intent.
+     * @param {sap.ushell.services.URLParsing.DecomposedHash} oParsedHash The parsed hash to check
+     * @returns {boolean} Whether the parsed hash represents the root intent
+     *
+     * @since 1.142.0
+     * @private
+     */
+    UrlParsing.isRootIntent = function (oParsedHash) {
+        const sRootIntent = ushellUtils.getRootIntent();
+        const oParsedRootIntent = this.parseShellHash(sRootIntent, true);
+        const oHashComparison = this.compareParsedHashes(oParsedHash, oParsedRootIntent);
+
+        return oHashComparison.sameIntent && oHashComparison.sameParameters;
+    };
+
+    /**
+     * Checks whether the given shell hash is empty.
+     * @param {sap.ushell.services.URLParsing.ShellHash} oShellHash The shell hash to check
+     * @returns {boolean} Whether the shell hash is empty
+     *
+     * @since 1.142.0
+     * @private
+     */
+    UrlParsing.isEmptyHash = function (oShellHash) {
+        return this.constructShellHash(oShellHash) === "";
+    };
+
     return UrlParsing;
 });