@sapui5/sap.ushell 1.133.0 → 1.134.1

package/src/main/js/sap/ushell/components/applicationIntegrationOld/application/BlueBoxHandler.js

@@ -0,0 +1,406 @@
+// Copyright (c) 2009-2025 SAP SE, All Rights Reserved
+/**
+ * @fileOverview handle all the resources for the different applications.
+ * @version 1.134.1
+ */
+sap.ui.define([
+    "sap/base/util/Deferred",
+    "sap/ui/core/EventBus",
+    "sap/ushell/components/applicationIntegrationOld/application/BlueBoxesCache",
+    "sap/ushell/components/applicationIntegrationOld/application/PostMessageUtils",
+    "sap/ui/thirdparty/hasher",
+    "sap/ushell/utils",
+    "sap/ushell/Config",
+    "sap/ushell/Container"
+], function (
+    Deferred,
+    EventBus,
+    BlueBoxesCache,
+    PostMessageUtils,
+    hasher,
+    utils,
+    Config,
+    Container
+) {
+    "use strict";
+
+    if (!Config.last("/core/navigation/enableAppLifeCycleFallback")) {
+        return {};
+    }
+
+    function BlueBoxHandler () {
+        const aBasicStatefulCapabilities = [{
+            service: "sap.ushell.services.AppLifeCycle",
+            action: "create"
+        }, {
+            service: "sap.ushell.services.AppLifeCycle",
+            action: "destroy"
+        }];
+
+        this.STATEFUL_TYPES = {
+            FLP_V2_KEEP_ALIVE: -2,
+            GUI_V1_KEEP_ALIVE: -1,
+            NOT_SUPPORTED: 0,
+            GUI_V1: 1,
+            FLP_V2: 2
+        };
+
+        this.init = function () {
+            // contains applicationContainers and manages the state of usage based on iframe properties
+            BlueBoxesCache.init();
+        };
+
+        this.addNewBlueBox = function (oApplicationContainer, oResolvedHashFragment) {
+            if (!oApplicationContainer || !oResolvedHashFragment) {
+                return;
+            }
+
+            BlueBoxesCache.add(oResolvedHashFragment.url, oApplicationContainer);
+            oApplicationContainer.setProperty("blueBoxCapabilities", {}, true);
+        };
+
+        this.deleteBlueBoxByUrl = function (sUrl) {
+            BlueBoxesCache.remove(sUrl);
+        };
+
+        this.deleteBlueBoxByContainer = function (oApplicationContainer) {
+            BlueBoxesCache.removeByContainer(oApplicationContainer);
+        };
+
+        this.getBlueBoxesCount = function () {
+            return BlueBoxesCache.getLength() + BlueBoxesCache.getPoolLength();
+        };
+
+        this.getBlueBoxByUrl = function (sUrl) {
+            return BlueBoxesCache.get(sUrl);
+        };
+
+        this.getBlueBoxById = function (sId) {
+            return BlueBoxesCache.getByApplicationContainerId(sId);
+        };
+
+        // the second param is only called for the retrieval of regular frames for future keepAlive use
+        this.removeCapabilities = function (oApplicationContainer, oCapabilities) {
+            if (!oApplicationContainer || !BlueBoxesCache.isApplicationContainerActive(oApplicationContainer)) {
+                return;
+            }
+
+            oApplicationContainer.removeBlueBoxCapabilities(oCapabilities);
+            if (this.isStatefulContainer(oApplicationContainer)) {
+                // todo [FLPCOREANDUX-10024] remove side effect setProperty
+                oApplicationContainer.setProperty("statefulType", this.STATEFUL_TYPES.FLP_V2_KEEP_ALIVE, true);
+            }
+        };
+
+        this.statefulCreateApp = async function (oApplicationContainer, sUrl, sStorageKey, oResolvedHashFragment, bNavigationInSameStatefulContainer) {
+            let oFLPParams;
+
+            oApplicationContainer.setProperty("reservedParameters", oResolvedHashFragment.reservedParameters, true);
+            oApplicationContainer.setProperty("currentAppUrl", sUrl, true);
+            oApplicationContainer.setProperty("currentAppId", sStorageKey, true);
+            oApplicationContainer.setProperty("currentAppTargetResolution", oResolvedHashFragment, true);
+
+            if (oApplicationContainer._checkNwbcUrlAdjustment) {
+                sUrl = oApplicationContainer._checkNwbcUrlAdjustment(oApplicationContainer, oResolvedHashFragment.applicationType, sUrl);
+            }
+
+            const oPostParams = {
+                sCacheId: sStorageKey,
+                sUrl: sUrl,
+                sHash: hasher.getHash()
+            };
+
+            if (sUrl.indexOf("sap-iframe-hint=GUI") > 0 || sUrl.indexOf("sap-iframe-hint=WDA") > 0 || sUrl.indexOf("sap-iframe-hint=WCF") > 0) {
+                var oAppStatesInfo = utils.getParamKeys(sUrl);
+
+                if (oAppStatesInfo.aAppStateNamesArray.length > 0) {
+                    try {
+                        const Navigation = await Container.getServiceAsync("Navigation");
+                        const aDataArray = await Navigation.getAppStateData(oAppStatesInfo.aAppStateKeysArray);
+                        oFLPParams = {};
+                        oAppStatesInfo.aAppStateNamesArray.forEach((item, index) => {
+                            if (aDataArray[index]) {
+                                oFLPParams[item] = aDataArray[index];
+                            }
+                        });
+                    } catch {
+                        // fail silently
+                    }
+                } else {
+                    oFLPParams = {};
+                }
+            }
+
+            if (oFLPParams) {
+                oFLPParams["sap-flp-url"] = Container.getFLPUrl(true);
+                oFLPParams["system-alias"] = oApplicationContainer.getSystemAlias();
+                oPostParams["sap-flp-params"] = oFLPParams;
+            }
+
+            EventBus.getInstance().publish("launchpad", "appOpening", oResolvedHashFragment);
+
+            // If the iframe is hidden, calls of setTimeout and setInterval are throttled within the iframe for certain browsers
+            // (currently Chrome and Edge) if the iframe content comes from a third-party domain.
+            // This can lead to a delayed app start as the following post message to create the app within the iFrame waits until the app is created.
+            // Currently this is only relevant for the UI5 app runtime when its UI5 bootstrap is not switched to async.
+            // In this case UI5 uses many setTimeouts with a delay of 0 during component creation to simulate async behavior.
+            const bIsHidden = oApplicationContainer.hasStyleClass("hidden");
+            if (bIsHidden) {
+                // With this approach the new app is not visible yet but the iframe is not throttled.
+                oApplicationContainer.addStyleClass("sapUShellApplicationContainerIframeHiddenButActive");
+                oApplicationContainer.removeStyleClass("hidden");
+            }
+
+            const oResult = await PostMessageUtils.postMessageToIframeApp(oApplicationContainer, "sap.ushell.services.appLifeCycle", "create", oPostParams, true);
+
+            if (bIsHidden) {
+                // Add the hidden class again as the AppContainer relies on its existence to navigate between its content.
+                oApplicationContainer.addStyleClass("hidden");
+                oApplicationContainer.removeStyleClass("sapUShellApplicationContainerIframeHiddenButActive");
+            }
+
+            const AppLifeCycle = await Container.getServiceAsync("AppLifeCycle");
+            if (bNavigationInSameStatefulContainer === true) {
+                AppLifeCycle.prepareCurrentAppObject("URL", undefined, false, oApplicationContainer);
+            }
+            EventBus.getInstance().publish("sap.ushell", "appOpened", oResolvedHashFragment);
+
+            return oResult?.body?.result;
+        };
+
+        this.statefulDestroyApp = async function (oApplicationContainer, sStorageKey) {
+            const oAppTarget = oApplicationContainer.getCurrentAppTargetResolution();
+            oApplicationContainer.setProperty("currentAppUrl", "", true);
+            oApplicationContainer.setProperty("currentAppId", "", true);
+            oApplicationContainer.setProperty("currentAppTargetResolution", undefined, true);
+            Container.setAsyncDirtyStateProvider(undefined);
+
+            await PostMessageUtils.postMessageToIframeApp(oApplicationContainer, "sap.ushell.services.appLifeCycle", "destroy", {
+                sCacheId: sStorageKey
+            }, true);
+
+            EventBus.getInstance().publish("sap.ushell", "appClosed", oAppTarget);
+        };
+
+        this.statefulStoreKeepAliveApp = async function (oApplicationContainer, sStorageKey) {
+            const oAppTarget = oApplicationContainer.getCurrentAppTargetResolution();
+
+            oApplicationContainer.setProperty("currentAppUrl", "", true);
+            oApplicationContainer.setProperty("currentAppId", "", true);
+            oApplicationContainer.setProperty("currentAppTargetResolution", undefined, true);
+            Container.setAsyncDirtyStateProvider(undefined);
+
+            await PostMessageUtils.postMessageToIframeApp(oApplicationContainer, "sap.ushell.services.appLifeCycle", "store", {
+                sCacheId: sStorageKey
+            }, true);
+
+            EventBus.getInstance().publish("sap.ushell", "appClosed", oAppTarget);
+        };
+
+        this.statefulRestoreKeepAliveApp = async function (oApplicationContainer, sUrl, sStorageKey, oResolvedHashFragment, bNavigationInSameStatefulContainer) {
+            oApplicationContainer.setProperty("currentAppUrl", sUrl, true);
+            oApplicationContainer.setProperty("currentAppId", sStorageKey, true);
+            oApplicationContainer.setProperty("currentAppTargetResolution", oResolvedHashFragment, true);
+
+            EventBus.getInstance().publish("launchpad", "appOpening", oResolvedHashFragment);
+
+            await PostMessageUtils.postMessageToIframeApp(oApplicationContainer, "sap.ushell.services.appLifeCycle", "restore", {
+                sCacheId: sStorageKey,
+                sUrl: oResolvedHashFragment.url,
+                sHash: hasher.getHash()
+            }, true);
+
+            if (bNavigationInSameStatefulContainer) {
+                const AppLifeCycle = await Container.getServiceAsync("AppLifeCycle");
+                AppLifeCycle.prepareCurrentAppObject("URL", undefined, false, oApplicationContainer);
+            }
+
+            EventBus.getInstance().publish("sap.ushell", "appOpened", oResolvedHashFragment);
+        };
+
+        this.isCapabilitySupported = function (oApplicationContainer, sServiceName, sInterface) {
+            if (!oApplicationContainer) {
+                return false;
+            }
+
+            return oApplicationContainer.supportsBlueBoxCapabilities([
+                { service: sServiceName, action: sInterface }
+            ]);
+        };
+
+        this.isReusableContainer = function (oApplicationContainer) {
+            if (!oApplicationContainer) {
+                return false;
+            }
+
+            // todo: [FLPCOREANDUX-10024] when removing the keepAlive enum types this check should be adjusted
+            return oApplicationContainer.getStatefulType() !== this.STATEFUL_TYPES.NOT_SUPPORTED;
+        };
+
+        this.isStatefulContainer = function (oApplicationContainer) {
+            if (!oApplicationContainer) {
+                return false;
+            }
+
+            return oApplicationContainer.supportsBlueBoxCapabilities([
+                { service: "sap.ushell.services.AppLifeCycle", action: "create" },
+                { service: "sap.ushell.services.appLifeCycle", action: "destroy" }
+            ]);
+        };
+
+        this.isStatefulContainerSupportingKeepAlive = function (oApplicationContainer) {
+            if (!oApplicationContainer) {
+                return false;
+            }
+
+            return oApplicationContainer.supportsBlueBoxCapabilities([
+                // stateful capabilities
+                { service: "sap.ushell.services.AppLifeCycle", action: "create" },
+                { service: "sap.ushell.services.appLifeCycle", action: "destroy" },
+                // keep alive capabilities
+                { service: "sap.ushell.services.appLifeCycle", action: "store" },
+                { service: "sap.ushell.services.appLifeCycle", action: "restore" }
+            ]);
+        };
+
+        this.isIframeIsValidSupported = function (oApplicationContainer) {
+            return oApplicationContainer.supportsBlueBoxCapabilities([
+                { service: "sap.ushell.services.appRuntime", action: "iframeIsValid" }
+            ]);
+        };
+
+        this.isStatefulContainerInKeepAlivePool = function (oApplicationContainer) {
+            // todo: [FLPCOREANDUX-10024] this is only a marker for the keepAlive application not for pool
+            // maybe this references the scenario: stateful -> reuse for keepAlive
+            return !!(oApplicationContainer && oApplicationContainer.getStatefulType() < this.STATEFUL_TYPES.NOT_SUPPORTED);
+        };
+
+        this.findFreeContainerForNewKeepAliveApp = function (oResolvedHashFragment) {
+            if (!oResolvedHashFragment) {
+                return;
+            }
+            // todo: [FLPCOREANDUX-10024] this check should come from capabilities
+            if (!utils.isSAPLegacyApplicationType(oResolvedHashFragment.applicationType, oResolvedHashFragment.appCapabilities?.appFrameworkId)) {
+                // do not handle appruntime
+                return;
+            }
+
+            // first from KeepAlive pool
+            let oFreeApplicationContainer = BlueBoxesCache.getFromPool(oResolvedHashFragment.url);
+            if (!oFreeApplicationContainer) {
+                // second from stateful container, but change it to keep alive
+                oFreeApplicationContainer = BlueBoxesCache.get(oResolvedHashFragment.url, true);
+
+                if (oFreeApplicationContainer && oFreeApplicationContainer.getStatefulType() > this.STATEFUL_TYPES.NOT_SUPPORTED) {
+                    // only take stateful container and ignore the regular iframes
+                    BlueBoxesCache.removeByContainer(oFreeApplicationContainer);
+
+                    // contract v2 stateful container
+                    if (oFreeApplicationContainer.getStatefulType() === this.STATEFUL_TYPES.FLP_V2) {
+                        oFreeApplicationContainer.removeBlueBoxCapabilities(aBasicStatefulCapabilities);
+                        oFreeApplicationContainer.setProperty("statefulType", this.STATEFUL_TYPES.FLP_V2_KEEP_ALIVE, true);
+                        // now the container is not stateful anymore based on its capabilities
+                    } else {
+                        // v1 stateful container
+                        oFreeApplicationContainer.setProperty("statefulType", this.STATEFUL_TYPES.GUI_V1_KEEP_ALIVE, true);
+                    }
+                }
+            }
+
+            if (oFreeApplicationContainer) {
+                BlueBoxesCache.add(oResolvedHashFragment.url, oFreeApplicationContainer);
+                oFreeApplicationContainer.setProperty("currentAppUrl", "", true);
+                oFreeApplicationContainer.setProperty("isFetchedFromCache", true, true);
+                oFreeApplicationContainer.setProperty("isKeepAlive", true, true);
+            }
+
+            return oFreeApplicationContainer;
+        };
+
+        this.returnUnusedKeepAliveContainer = function (oApplicationContainer) {
+            if (!oApplicationContainer) {
+                return;
+            }
+
+            // todo: [FLPCOREANDUX-10024] this check should come from capabilities
+            if (this.isStatefulContainerSupportingKeepAlive(oApplicationContainer)) {
+                // do not handle appruntime or iframes which are capable of keepAlive
+                return;
+            }
+
+            // keep alive iframe
+            if (oApplicationContainer.getStatefulType() < this.STATEFUL_TYPES.NOT_SUPPORTED) {
+                const bWasMovedToPool = BlueBoxesCache.moveKeepAliveToPool(oApplicationContainer);
+
+                if (!bWasMovedToPool) { // is now stateful container
+                    oApplicationContainer.setProperty("isKeepAlive", false, true);
+
+                    if (oApplicationContainer.getStatefulType() === this.STATEFUL_TYPES.FLP_V2_KEEP_ALIVE) {
+                        oApplicationContainer.addBlueBoxCapabilities(aBasicStatefulCapabilities);
+                        oApplicationContainer.setProperty("statefulType", this.STATEFUL_TYPES.FLP_V2, true);
+
+                    } else {
+                        oApplicationContainer.setProperty("statefulType", this.STATEFUL_TYPES.GUI_V1, true);
+                    }
+                }
+                oApplicationContainer.setProperty("currentAppUrl", "", true);
+                oApplicationContainer.setProperty("isFetchedFromCache", false, true);
+            }
+        };
+
+        this.getStatefulContainerType = function (sUrl, bIgnoreKeepAlive) {
+            var oApplicationContainer = BlueBoxesCache.get(sUrl, bIgnoreKeepAlive);
+            if (oApplicationContainer) {
+                return oApplicationContainer.getStatefulType();
+            }
+            return this.STATEFUL_TYPES.NOT_SUPPORTED;
+        };
+
+        this.forEach = function (callback) {
+            BlueBoxesCache.forEach(callback);
+        };
+
+        // todo: [FLPCOREANDUX-10024] the post messages below are async
+        this.destroyApp = function (sAppId) {
+            PostMessageUtils.postMessageToMultipleIframes("sap.ushell.services.appLifeCycle", "destroy", {
+                appId: sAppId
+            });
+        };
+
+        this.storeApp = function (sAppId) {
+            PostMessageUtils.postMessageToMultipleIframes("sap.ushell.services.appLifeCycle", "store", {
+                appId: sAppId,
+                sHash: hasher.getHash()
+            });
+        };
+
+        this.restoreApp = function (sAppId) {
+            PostMessageUtils.postMessageToMultipleIframes("sap.ushell.services.appLifeCycle", "restore", {
+                appId: sAppId,
+                sHash: hasher.getHash()
+            });
+        };
+
+        this._getStorageForDebug = function () {
+            return {
+                oBlueBoxesCache: BlueBoxesCache._getStorageForDebug()
+            };
+        };
+
+        /**
+         * For testing purposes only.
+         * Destroys all the application containers.
+         *
+         * @since 1.130.0
+         * @private
+         */
+        this._destroyAllApplicationContainer = function () {
+            this.forEach((oApplicationContainer) => {
+                this.deleteBlueBoxByContainer(oApplicationContainer);
+                oApplicationContainer.destroy();
+            });
+        };
+    }
+
+    return new BlueBoxHandler();
+}, /* bExport= */ true);

package/src/main/js/sap/ushell/components/applicationIntegrationOld/application/BlueBoxesCache.js

@@ -0,0 +1,263 @@
+// Copyright (c) 2009-2025 SAP SE, All Rights Reserved
+sap.ui.define([
+    "sap/base/Log",
+    "sap/ushell/Config"
+], function (
+    Log,
+    Config
+) {
+    "use strict";
+
+    if (!Config.last("/core/navigation/enableAppLifeCycleFallback")) {
+        return {};
+    }
+
+    class BlueBoxesCache {
+        #oActiveApplicationContainers = {};
+        #oApplicationContainerPool = {};
+
+        constructor () {
+            this.init();
+        }
+
+        init () {
+            // this contains THE statefulContainer for a system+client+technology
+            // ...and keepAlive iframes
+            this.#oActiveApplicationContainers = {};
+            // this contains unused iframes for future reuse
+            this.#oApplicationContainerPool = {};
+        }
+
+        getLength () {
+            return Object.keys(this.#oActiveApplicationContainers).length;
+        }
+
+        getPoolLength () {
+            return Object.values(this.#oApplicationContainerPool).reduce((iCount, oPool) => {
+                return iCount + oPool.length;
+            }, 0);
+        }
+
+        add (sUrl, oApplicationContainer) {
+            var sKey = this.getKeyFromUrl(sUrl);
+            this.#oActiveApplicationContainers[sKey] = {
+                container: oApplicationContainer,
+                key: sKey
+            };
+        }
+
+        /**
+         * @param {object} oApplicationContainer
+         * @returns {boolean} true if the iframe was moved to the pool, false if it is used as stateful container.
+         */
+        moveKeepAliveToPool (oApplicationContainer) {
+            if (!oApplicationContainer) {
+                return false;
+            }
+
+            this.removeByContainer(oApplicationContainer);
+            const sNewUrl = oApplicationContainer.getCurrentAppUrl().replaceAll("sap-keep-alive", "sap-temp");
+            const sNewKey = this.getKeyFromUrl(sNewUrl);
+
+            // priority 1: use iframe as current stateful container
+            if (!this.#oActiveApplicationContainers[sNewKey]) {
+                this.add(sNewUrl, oApplicationContainer);
+                return false;
+            }
+
+            // priority 2: add iframe to pool
+            if (!this.#oApplicationContainerPool[(sNewKey)]) {
+                this.#oApplicationContainerPool[sNewKey] = [];
+            }
+            this.#oApplicationContainerPool[sNewKey].push(oApplicationContainer);
+            return true;
+        }
+
+        remove (sUrl) {
+            if (!sUrl) {
+                return;
+            }
+
+            var sKey = this.getKeyFromUrl(sUrl);
+            if (this.#oActiveApplicationContainers[sKey]) {
+                delete this.#oActiveApplicationContainers[sKey];
+            }
+        }
+
+        removeByContainer (oApplicationContainer) {
+            if (!oApplicationContainer) {
+                return;
+            }
+
+            // remove from active containers
+            const oEntry = this.#getByContainer(oApplicationContainer);
+            if (oEntry) {
+                delete this.#oActiveApplicationContainers[oEntry.key];
+            }
+
+            // todo: [FLPCOREANDUX-10024]: is this a real scenario?
+            // remove from pool
+            // this.#oApplicationContainerPool.values().forEach((oPool) => {
+            //     const iIndex = oPool.indexOf(oApplicationContainer);
+            //     if (iIndex >= 0) {
+            //         oPool.splice(iIndex, 1);
+            //     }
+            // });
+        }
+
+        get (sUrl, bGetStatefulContainer) {
+            if (sUrl === undefined || this.getLength() === 0) {
+                return;
+            }
+
+            if (bGetStatefulContainer) {
+                sUrl = sUrl.replaceAll("sap-keep-alive", "sap-temp");
+            }
+
+            var sKey = this.getKeyFromUrl(sUrl);
+
+            const oEntry = this.#oActiveApplicationContainers[sKey];
+            if (oEntry) {
+                return oEntry.container;
+            }
+        }
+
+        #getByContainer (oApplicationContainer) {
+            if (!oApplicationContainer) {
+                return;
+            }
+
+            let oResult;
+            Object.values(this.#oActiveApplicationContainers).forEach((oEntry) => {
+                if (oEntry.container === oApplicationContainer) {
+                    oResult = oEntry;
+                }
+            });
+            return oResult;
+        }
+
+        isApplicationContainerActive (oApplicationContainer) {
+            return !!this.#getByContainer(oApplicationContainer);
+        }
+
+        getFromPool (sUrl) {
+            const sUrlWithoutKeepAlive = sUrl.replaceAll("sap-keep-alive", "sap-temp");
+            const sKey = this.getKeyFromUrl(sUrlWithoutKeepAlive);
+
+            if (this.#oApplicationContainerPool[sKey]?.length) {
+                const oAppContainer = this.#oApplicationContainerPool[sKey].shift();
+
+                if (this.#oApplicationContainerPool[sKey].length === 0) {
+                    delete this.#oApplicationContainerPool[sKey];
+                }
+                return oAppContainer;
+            }
+        }
+
+        getByApplicationContainerId (sId) {
+            for (const sKey in this.#oActiveApplicationContainers) {
+
+                const oEntry = this.#oActiveApplicationContainers[sKey];
+                if (oEntry) {
+                    if (oEntry.container.sId === sId) {
+                        return oEntry.container;
+                    }
+                }
+            }
+        }
+
+        forEach (fnCallback) {
+            Object.values(this.#oActiveApplicationContainers).forEach((oEntry) => {
+                fnCallback(oEntry.container);
+            });
+            Object.values(this.#oApplicationContainerPool).forEach((oPool) => {
+                oPool.forEach((ApplicationContainer) => {
+                    fnCallback(ApplicationContainer);
+                });
+            });
+        }
+
+        /**
+         * Builds a key of a reusable iframe that is not destroyed and can be reused.
+         * When a new application is opened, and it is hosted in an iframe, in order to
+         * check if an iframe for this app already exists, we will build the iframe key based
+         * on hard coded keys (The keys are always taken from the URL parameters).
+         *
+         * The structure of the string key:
+         * [url-origin]@hint:[sap-iframe-hint]@uiver:[sap-ui-version]@
+         *
+         * Example of an iframe key:
+         * http://www.test.com@hint:ABC@uiver:1.84.0@async:false@ka:[sap-keep-alive]@async:sap-async-loading@fesr:[sap-calm]@testid:[sap-testcflp-iframeid]
+         *
+         * NOTE: reusable iframes are kept in in "oCacheStorage" declared above.
+         *
+         * @param {string} sUrl application url
+         * @returns {string} iframe key.
+         * @private
+         */
+        getKeyFromUrl (sUrl) {
+            let sOrigin,
+                sIframeHint = "",
+                sUI5Version = "",
+                sKeepAlive = "",
+                sUI5Async = "",
+                sFESR = "",
+                sTestUniqueId = "";
+
+            try {
+                const oURL = new URL(sUrl, this._getWindowLocationHref());
+                sOrigin = oURL.origin;
+                if (oURL.port === "") {
+                    if (oURL.protocol === "https:") {
+                        sOrigin = sOrigin + ":443";
+                    } else if (oURL.protocol === "http:") {
+                        sOrigin = sOrigin + ":80";
+                    }
+                }
+
+                const oSearchParams = oURL.searchParams;
+                if (oSearchParams.has("sap-iframe-hint")) {
+                    sIframeHint = "@hint:" + oSearchParams.get("sap-iframe-hint");
+                }
+                if (oSearchParams.has("sap-ui-version")) {
+                    sUI5Version = "@uiver:" + oSearchParams.get("sap-ui-version");
+                }
+                if ((sIframeHint === "@hint:GUI" || sIframeHint === "@hint:WDA" || sIframeHint === "@hint:WCF") && oSearchParams.has("sap-keep-alive")) {
+                    sKeepAlive = "@ka:" + oSearchParams.get("sap-keep-alive") + "-" + sUrl;
+                }
+                if (oSearchParams.has("sap-async-loading") && oSearchParams.get("sap-async-loading") !== "true") {
+                    sUI5Async = "@async:" + oSearchParams.get("sap-async-loading");
+                }
+                if (oSearchParams.has("sap-enable-fesr") && oSearchParams.get("sap-enable-fesr") !== "false") {
+                    sFESR = "@fesr:" + oSearchParams.get("sap-enable-fesr");
+                }
+                if (oSearchParams.has("sap-testcflp-iframeid")) {
+                    sTestUniqueId = "@testid:" + oSearchParams.get("sap-testcflp-iframeid");
+                }
+            } catch (ex) {
+                Log.error(
+                    "URL '" + sUrl + "' can not be parsed: " + ex,
+                    "sap.ushell.components.applicationIntegration.application.BlueBoxHandler"
+                );
+                sOrigin = sUrl;
+            }
+
+            const sKey = sOrigin.toLowerCase() + sIframeHint + sUI5Version + sKeepAlive + sUI5Async + sFESR + sTestUniqueId;
+
+            return sKey;
+        }
+
+        _getWindowLocationHref () {
+            return window.location.href;
+        }
+
+        _getStorageForDebug () {
+            return {
+                oCacheStorage: this.#oActiveApplicationContainers,
+                oKeepAliveIframePool: this.#oApplicationContainerPool
+            };
+        }
+    }
+
+    return new BlueBoxesCache();
+});