@sapui5/sap.ushell 1.133.0 → 1.134.1

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

@@ -0,0 +1,143 @@
+// Copyright (c) 2009-2025 SAP SE, All Rights Reserved
+
+sap.ui.define([
+    "sap/base/util/deepExtend",
+    "sap/ui/thirdparty/jquery",
+    "sap/ushell/Config"
+], function (
+    deepExtend,
+    jQuery,
+    Config
+) {
+    "use strict";
+
+    if (!Config.last("/core/navigation/enableAppLifeCycleFallback")) {
+        return {};
+    }
+
+    var USER_API_PREFIX = "user.postapi.";
+
+    /**
+     * @private
+     */
+    function PostMessageAPIInterface () {
+        var _bIsFLP,
+            _fnDoRegistration;
+
+        /**
+         * @private
+         */
+        this.init = function (bIsFLP, fnDoRegistration) {
+            _bIsFLP = bIsFLP;
+            _fnDoRegistration = fnDoRegistration;
+        };
+
+        /**
+         * @private
+         */
+        this.getInterface = function () {
+            var oInterface = {};
+
+            oInterface.registerPostMessageAPIs = registerUserPostMessageAPIs.bind(null, _fnDoRegistration);
+            oInterface[(_bIsFLP === true ? "postMessageToApp" : "postMessageToFlp")] = doPostMessage.bind(null, _bIsFLP);
+            oInterface.createPostMessageResult = createPostMessageResult;
+            return oInterface;
+        };
+    }
+
+    /**
+     * @private
+     */
+    function registerUserPostMessageAPIs (fnDoRegistration, oPostMessageAPIs, bSAPInternal) {
+        var oRes = {
+            status: "success",
+            desc: ""
+        };
+        var oDefaultInCallProps = {
+            isActiveOnly: true,
+            distributionType: ["all"]
+        };
+
+        if (oPostMessageAPIs === undefined || Object.keys(oPostMessageAPIs).length <= 0) {
+            oRes.status = "error";
+            oRes.desc = "no handler was found to register";
+            return oRes;
+        }
+
+        if (bSAPInternal === undefined) {
+            bSAPInternal = false;
+        }
+        Object.keys(oPostMessageAPIs).forEach(function (sService) {
+            if (typeof sService !== "string") {
+                oRes.status = "error";
+                oRes.desc = "oPostMessageAPIs should contain only string keys";
+            } else if (bSAPInternal === false && sService.indexOf(USER_API_PREFIX) !== 0) {
+                oRes.status = "error";
+                oRes.desc = "all user custom Message APIs must start with '" + USER_API_PREFIX + "'";
+            } else {
+                Object.keys(oPostMessageAPIs[sService]).forEach(function (sType) {
+                    if (sType == "inCalls") {
+                        oPostMessageAPIs[sService].oServiceCalls = oPostMessageAPIs[sService][sType];
+                        delete oPostMessageAPIs[sService][sType];
+                    } else if (sType == "outCalls") {
+                        Object.keys(oPostMessageAPIs[sService][sType]).forEach(function (sMethod) {
+                            oPostMessageAPIs[sService][sType][sMethod] = deepExtend({}, oDefaultInCallProps, oPostMessageAPIs[sService][sType][sMethod]);
+                        });
+                        oPostMessageAPIs[sService].oRequestCalls = oPostMessageAPIs[sService][sType];
+                        delete oPostMessageAPIs[sService][sType];
+                    } else {
+                        oRes.status = "error";
+                        oRes.desc = "api should contain either 'inCalls' or 'outCalls'";
+                    }
+                });
+            }
+        });
+
+        if (oRes.status === "success") {
+            fnDoRegistration(oPostMessageAPIs);
+        }
+
+        return oRes;
+    }
+
+    /**
+     * @private
+     */
+    function doPostMessage (bIsFLP, sServiceName, sInterface, oParams) {
+        var oDeferred = new jQuery.Deferred();
+
+        if (oParams === undefined) {
+            oParams = {};
+        }
+
+        if (bIsFLP) {
+            sap.ui.require(["sap/ushell/components/applicationIntegrationOld/application/PostMessageUtils"], function (PostMessageUtils) {
+                PostMessageUtils.postMessageToMultipleIframes(sServiceName, sInterface, oParams, true)
+                    .then(function (oResult) {
+                        oDeferred.resolve(oResult && oResult[0] && oResult[0].body.result);
+                    });
+            });
+        } else {
+            sap.ui.require(["sap/ushell/appRuntime/ui5/AppRuntimeService"], function (AppRuntimeService) {
+                AppRuntimeService.sendMessageToOuterShell(sServiceName + "." + sInterface, oParams)
+                    .done(function (oResult) {
+                        oDeferred.resolve(oResult);
+                    });
+            });
+        }
+
+        return oDeferred.promise();
+    }
+
+    /**
+     * @private
+     */
+    function createPostMessageResult (oResult) {
+        if (oResult === undefined) {
+            oResult = {};
+        }
+        return new jQuery.Deferred().resolve(oResult).promise();
+    }
+
+    return new PostMessageAPIInterface();
+});

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

@@ -0,0 +1,192 @@
+// Copyright (c) 2009-2025 SAP SE, All Rights Reserved
+/**
+ * @file This file contains miscellaneous utility functions for post message communication
+ */
+sap.ui.define([
+    "sap/base/Log",
+    "sap/ui/thirdparty/URI",
+    "sap/ushell/Config"
+], function (
+    Log,
+    URI,
+    Config
+) {
+    "use strict";
+
+    if (!Config.last("/core/navigation/enableAppLifeCycleFallback")) {
+        return {};
+    }
+
+    var oApplication,
+        oBlueBoxHandler;
+
+    var PostMessageUtils = {};
+
+    PostMessageUtils.init = function (inApplication, inBlueBoxHandler) {
+        oApplication = inApplication;
+        oBlueBoxHandler = inBlueBoxHandler;
+    };
+
+    PostMessageUtils.createPostMessageRequest = function (sServiceName, oMessageBody) {
+        var sRequestId = Date.now().toString();
+
+        return {
+            type: "request",
+            request_id: sRequestId,
+            service: sServiceName,
+            body: oMessageBody || {}
+        };
+    };
+
+    PostMessageUtils.createPostMessageResponse = function (sServiceName, sRequestId, oMessageBody, bSuccess) {
+        return {
+            type: "response",
+            request_id: sRequestId,
+            service: sServiceName,
+            status: (bSuccess ? "success" : "error"),
+            body: oMessageBody || {}
+        };
+    };
+
+    PostMessageUtils.postMessageToIframeApp = function (oContainer, sServiceName, sInterface, oMessageBody, bWaitForResponse) {
+        var sService = sServiceName + "." + sInterface,
+            oMessage = this.createPostMessageRequest(sService, oMessageBody);
+
+        return this.postMessageToIframe(oMessage, oContainer, bWaitForResponse);
+    };
+
+    PostMessageUtils.postMessageToIframe = function (oMessage, oContainer, bWaitForResponse) {
+        var oIFrame = oContainer._getIFrame && oContainer._getIFrame(),
+            oUri,
+            sTargetDomain;
+
+        if (!oIFrame || !oContainer._getIFrameUrl) {
+            return Promise.resolve();
+        }
+
+        oUri = new URI(oContainer._getIFrameUrl(oIFrame));
+        sTargetDomain = oUri.protocol() + "://" + oUri.host();
+
+        return this.postMessageToIframeObject(oMessage, oIFrame, sTargetDomain, bWaitForResponse, true);
+    };
+
+    PostMessageUtils.postMessageToIframeObject = function (oMessage, oIFrame, sTargetDomain, bWaitForResponse, bFromContainer) {
+        var sRequestId = oMessage.request_id;
+
+        return new Promise(function (fnNotifySuccess, fnNotifyError) {
+            function fnProcessClientMessage (oEvent) {
+                var oEventData;
+
+                try {
+                    //only messages from the
+                    if ((bFromContainer === true ? oIFrame.contentWindow : oIFrame) !== oEvent.source) {
+                        return;
+                    }
+
+                    if (typeof oEvent.data === "string" && oEvent.data.indexOf("{") === 0) {
+                        try {
+                            oEventData = JSON.parse(oEvent.data);
+                        } catch (e) {
+                            oEventData = {};
+                        }
+                    } else {
+                        return;
+                    }
+
+                    if (!oEventData.request_id || sRequestId !== oEventData.request_id) {
+                        return;
+                    }
+
+                    window.removeEventListener("message", fnProcessClientMessage);
+
+                    if (oEventData.status === "success") {
+                        fnNotifySuccess(oEventData);
+                    } else {
+                        fnNotifyError(oEventData);
+                    }
+                } catch (e) {
+                    // Not gonna break because of a potential quirk in the framework that responded to postMessage
+                    fnNotifySuccess();
+                    Log.warning("Obtained bad response from framework in response to message " + oMessage.request_id);
+                    Log.debug("Underlying framework returned invalid response data: '" + oEvent.data + "'");
+                }
+            }
+
+            if (!oIFrame) {
+                fnNotifySuccess();
+            } else {
+                var sMessage = JSON.stringify(oMessage);
+
+                Log.debug("Sending postMessage " + sMessage + " to iframe with domain '" + sTargetDomain + "'");
+                if (bWaitForResponse === true) {
+                    window.addEventListener("message", fnProcessClientMessage, false);
+                    if (bFromContainer === true) {
+                        oIFrame.contentWindow.postMessage(sMessage, sTargetDomain);
+                    } else {
+                        oIFrame.postMessage(sMessage, sTargetDomain);
+                    }
+                } else {
+                    if (bFromContainer === true) {
+                        oIFrame.contentWindow.postMessage(sMessage, sTargetDomain);
+                    } else {
+                        oIFrame.postMessage(sMessage, sTargetDomain);
+                    }
+                    fnNotifySuccess();
+                }
+            }
+        });
+    };
+
+    PostMessageUtils.postMessageToMultipleIframes = function (sServiceName, sInterface, oMessageBody, bWaitForResponse) {
+        //this is a temporary check that will be removed after the issue of the central logout
+        //will be implemented. In the case here, for FLP@ABAP, we do not want to send logout message to
+        //CRM, WebGui and WDA iframes ifames as this is not needed. Sending it will cause an issue with the
+        //main FLP logout
+        function checkIfPostIsNeeded (oCurrContainer) {
+            if (sServiceName === "sap.ushell.sessionHandler" && sInterface === "logout") {
+                if (oCurrContainer && oCurrContainer.getApplicationType && ",WCF,GUI,TR,WDA,".indexOf(oCurrContainer.getApplicationType()) > 0) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        if (!oApplication || !oBlueBoxHandler) {
+            return Promise.all([]);
+        }
+
+        var oContainer = oApplication.getActiveAppContainer(),
+            bActiveContainerPostSent = false,
+            aContainers = [];
+        // todo: [FLPCOREANDUX-10024]: cleanup and use supportsBlueBoxCapabilities on the oApplicationContainer.
+        if (oContainer && oContainer._getIFrame && oContainer._getIFrame() &&
+            (oBlueBoxHandler.isCapabilitySupported(oContainer, sServiceName, sInterface) || oApplication.isAppTypeSupported(oContainer, sServiceName, sInterface)) &&
+            checkIfPostIsNeeded(oContainer) === true) {
+            aContainers.push(
+                PostMessageUtils.postMessageToIframeApp(oContainer, sServiceName, sInterface, oMessageBody, bWaitForResponse)
+            );
+            bActiveContainerPostSent = true;
+        }
+
+        //for all other stored applications
+        if (oBlueBoxHandler.getBlueBoxesCount() > 0 && !oApplication.isActiveOnly(sServiceName, sInterface)) {
+            oBlueBoxHandler.forEach(function (OBBContainer) {
+                if (bActiveContainerPostSent === true && OBBContainer === oContainer) {
+                    return;
+                }
+                if (OBBContainer._getIFrame && OBBContainer._getIFrame()) {
+                    if ((oBlueBoxHandler.isCapabilitySupported(OBBContainer, sServiceName, sInterface) || oApplication.isAppTypeSupported(OBBContainer, sServiceName, sInterface)) &&
+                        checkIfPostIsNeeded(OBBContainer) === true) {
+                        aContainers.push(
+                            PostMessageUtils.postMessageToIframeApp(OBBContainer, sServiceName, sInterface, oMessageBody, bWaitForResponse)
+                        );
+                    }
+                }
+            });
+        }
+
+        return Promise.all(aContainers);
+    };
+
+    return PostMessageUtils;
+}, /* bExport= */ false);

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

@@ -0,0 +1,90 @@
+// Copyright (c) 2009-2025 SAP SE, All Rights Reserved
+/**
+ * @file This file contains miscellaneous utility functions for WebGui stateful container V1
+ */
+sap.ui.define([
+    "sap/ushell/utils",
+    "sap/ushell/components/applicationIntegrationOld/application/PostMessageUtils",
+    "sap/ushell/Config",
+    "sap/ushell/Container"
+], function (
+    ushellUtils,
+    PostMessageUtils,
+    Config,
+    Container
+) {
+    "use strict";
+
+    if (!Config.last("/core/navigation/enableAppLifeCycleFallback")) {
+        return {};
+    }
+
+    var WebGUIStatefulHandler = {};
+
+    WebGUIStatefulHandler.guiStatefulCreateApp = async function (oAppLifeCycle, oContainer, oTarget) {
+        if (oContainer.setCurrentAppUrl) {
+            oContainer.setProperty("currentAppUrl", oTarget.url, true);
+        }
+        if (oContainer.setCurrentAppTargetResolution) {
+            oContainer.setProperty("currentAppTargetResolution", oTarget, true);
+        }
+        oContainer.setProperty("iframeReusedForApp", true, true);
+
+        await PostMessageUtils.postMessageToIframeApp(oContainer, "sap.gui", "triggerCloseSessionImmediately", {}, true);
+
+        await createGuiApp(oContainer, oTarget);
+
+        // todo: [FLPCOREANDUX-10024] Move styles into control? or at least out of here
+        if (oContainer.hasStyleClass("sapUShellApplicationContainerShiftedIframe")) {
+            oContainer.toggleStyleClass("sapUShellApplicationContainerIframeHidden", false);
+        } else {
+            oContainer.toggleStyleClass("hidden", false);
+        }
+    };
+
+    WebGUIStatefulHandler.guiStatefulCloseCurrentApp = async function (oContainer) {
+        return PostMessageUtils.postMessageToIframeApp(oContainer, "sap.gui", "triggerCloseSession", {}, false);
+    };
+
+    async function createGuiApp (oContainer, oTarget) {
+        let sUrl = oTarget.url;
+
+        sUrl = await ushellUtils.appendSapShellParam(sUrl);
+        sUrl = ushellUtils.filterOutParamsFromLegacyAppURL(sUrl);
+
+        let oFLPParams;
+        const oPostParams = {
+            url: sUrl
+        };
+        if (oContainer.getIframeWithPost && oContainer.getIframeWithPost() === true) {
+            var oAppStatesInfo = ushellUtils.getParamKeys(sUrl);
+
+            if (oAppStatesInfo.aAppStateNamesArray.length > 0) {
+                const Navigation = await Container.getServiceAsync("Navigation");
+                try {
+                    const aDataArray = await Navigation.getAppStateData(oAppStatesInfo.aAppStateKeysArray);
+                    oFLPParams = {};
+                    oAppStatesInfo.aAppStateNamesArray.forEach(function (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"] = oContainer.getSystemAlias();
+            oPostParams["sap-flp-params"] = oFLPParams;
+        }
+
+        return PostMessageUtils.postMessageToIframeApp(oContainer, "sap.its", "startService", oPostParams, true);
+    }
+
+    return WebGUIStatefulHandler;
+}, /* bExport= */ false);

package/src/main/js/sap/ushell/components/applicationIntegrationOld/configuration/AppMeta.js

@@ -0,0 +1,193 @@
+// 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/ushell/services/AppConfiguration",
+    "sap/ui/Device",
+    "sap/ushell/Config",
+    "sap/ushell/utils",
+    "sap/ui/performance/Measurement",
+    "sap/ui/util/Mobile",
+    "sap/ui/core/Theming",
+    "sap/ushell/Container",
+    "sap/base/util/deepEqual"
+], function (
+    AppConfiguration,
+    Device,
+    Config,
+    ushellUtils,
+    Measurement,
+    Mobile,
+    Theming,
+    Container,
+    deepEqual
+) {
+    "use strict";
+
+    if (!Config.last("/core/navigation/enableAppLifeCycleFallback")) {
+        return {};
+    }
+
+    function AppMeta () {
+        /**
+         * Helper function to get the favicon image URL based on a given theme parameter.
+         */
+        this.bIconSet = {};
+
+        this._getFavicon = async function () {
+            let [sFavicon] = await ushellUtils.getThemingParameters(["sapUiShellFavicon"]);
+            let bCustomFavicon = false;
+            if (sFavicon) { // custom theme favicon
+                var match = /url[\s]*\('?"?([^'")]*)'?"?\)/.exec(sFavicon);
+                if (match) {
+                    sFavicon = match[1];
+                    bCustomFavicon = true;
+                } else if (sFavicon === "''" || sFavicon === "none") {
+                    sFavicon = null;
+                }
+            }
+
+            var sConfigFavicon = Config.last("/core/shell/favIcon");
+            if (sConfigFavicon && (sFavicon === null || sFavicon === undefined)) { // configuration favicon
+                sFavicon = sConfigFavicon;
+                bCustomFavicon = true;
+            }
+
+            if (!sFavicon) { // default favicon
+                var sModulePath = sap.ui.require.toUrl("sap/ushell");
+                sFavicon = sModulePath + "/themes/base/img/launchpad_favicon.ico";
+            }
+
+            return {
+                favicon: sFavicon,
+                isCustomFavicon: bCustomFavicon
+            };
+        };
+
+        this.getAppIcon = function () {
+            var sIcon = "sap-icon://folder";
+            var appMetaData = AppConfiguration.getMetadata();
+            if (appMetaData && appMetaData.icon) {
+                sIcon = appMetaData.icon;
+            }
+            return sIcon;
+        };
+
+        this.setAppIcons = function () {
+            // performance debug
+            Measurement.start("FLP:ShellController.setAppIcons", "setValues", "FLP");
+            Theming.attachApplied(() => this.setValues());
+
+            Measurement.end("FLP:ShellController.setAppIcons");
+        };
+
+        this.setValues = async function () {
+            var sModulePath = sap.ui.require.toUrl("sap/ushell");
+            var oDefaultFavicon = await this._getFavicon();
+            var sFavicon = oDefaultFavicon.favicon;
+
+            if (oDefaultFavicon.isCustomFavicon) {
+                const oIconArgs = {
+                    phone: sFavicon,
+                    "phone@2": sFavicon,
+                    tablet: sFavicon,
+                    "tablet@2": sFavicon,
+                    favicon: sFavicon,
+                    precomposed: false
+                };
+
+                if (deepEqual(this.bIconSet, oIconArgs)) {
+                    return;
+                }
+
+                Mobile.setIcons(oIconArgs);
+                this.bIconSet = oIconArgs;
+            } else {
+                const oIconArgs = {
+                    phone: sModulePath + "/themes/base/img/launchicons/phone-icon_120x120.png",
+                        "phone@2": sModulePath + "/themes/base/img/launchicons/phone-retina_180x180.png",
+                    tablet: sModulePath + "/themes/base/img/launchicons/tablet-icon_152x152.png",
+                    "tablet@2": sModulePath + "/themes/base/img/launchicons/tablet-retina_167x167.png",
+                    favicon: sFavicon,
+                    precomposed: false
+                };
+
+                if (deepEqual(this.bIconSet, oIconArgs)) {
+                    return;
+                }
+
+                Mobile.setIcons(oIconArgs);
+                this.bIconSet = oIconArgs;
+            }
+        };
+
+        // The following logic is applied for compact/cozy:
+        // - Pure touch devices: always cozy. Other settings are ignored.
+        // - Desktop and combi (laptops with a touch screen):
+        // -- If the application supports only one (compact or cozy), apply that one;
+        // -- If the application supports both, use the user preference from settings;
+        // -- If the application supports both and no user preference, take device default,
+        //    (device default is compact for desktop and cozy for combi).
+
+        // If application supports only one density, force it on desktop/combi.
+        // Otherwise, the same behavior as in _applyContentDensityClass.
+        this._applyContentDensityByPriority = async function (isCompact, isUserChange) {
+            if (isCompact === undefined) {
+                const appMetaData = AppConfiguration.getMetadata();
+                if (appMetaData.compactContentDensity && !appMetaData.cozyContentDensity) {
+                    isCompact = true;
+                } else if (!appMetaData.compactContentDensity && appMetaData.cozyContentDensity) {
+                    isCompact = false;
+                }
+            }
+            await this._applyContentDensityClass(isCompact, isUserChange);
+        };
+
+        this._applyContentDensityClass = async function (isCompact, isUserChange) {
+            function setClasses(compact) {
+                document.body.classList.toggle("sapUiSizeCompact", compact);
+                document.body.classList.toggle("sapUiSizeCozy", !compact);
+
+                if (isUserChange === true) {
+                    sap.ui.require(["sap/ushell/components/applicationIntegrationOld/application/PostMessageUtils"], function (PostMessageUtils) {
+                        PostMessageUtils.postMessageToMultipleIframes("sap.ushell.appRuntime", "uiDensityChange", { isTouch: (compact ? "0" : "1") });
+                    });
+                }
+            }
+
+            // on pure touch devices, force cozy (app support and user preference are both ignored)
+            if (!Device.system.desktop && !Device.system.combi) {
+                isCompact = false;
+            }
+
+            // apply user preference only on desktop/combi and only when the app supports both densities
+            if (isCompact === undefined) {
+                const userInfoService = await Container.getServiceAsync("UserInfo");
+                const sContentDensity = userInfoService.getUser?.()?.getContentDensity();
+                if (sContentDensity === "compact") {
+                    isCompact = true;
+                } else if (sContentDensity === "cozy") {
+                    isCompact = false;
+                } else {
+                    isCompact = this._isCompactContentDensityByDevice();
+                }
+            }
+            setClasses(!!isCompact);
+        };
+
+        // Default content density for touch (including combi) devices is cozy.
+        this._isCompactContentDensityByDevice = function () {
+            return !Device.support.touch;
+        };
+
+        this.restore = function () {
+            this._applyContentDensityByPriority();
+            this.setAppIcons();
+        };
+    }
+
+    return new AppMeta();
+}, /* bExport= */ true);