@sapui5/sap.ushell 1.140.0 → 1.141.1

package/src/main/js/sap/ushell/services/MessageBroker/MessageBrokerEngine.js

@@ -2,839 +2,660 @@
 
 /**
  * @fileOverview This module contains the implementation of the message broker
- * @version 1.140.0
+ * @version 1.141.1
  */
 sap.ui.define([
     "sap/base/Log",
-    "sap/base/util/deepExtend"
+    "sap/base/util/deepClone",
+    "sap/ushell/services/MessageBroker/ClientAlias",
+    "sap/ushell/services/MessageBroker/ClientConnectionMessage"
 ], (
     Log,
-    deepExtend
+    deepClone,
+    ClientAlias,
+    ClientConnectionMessage
 ) => {
     "use strict";
 
-    let bEnabled = true;
-    const oAcceptedOrigins = {};
-    const oClientsPerChannel = {};
-    const oConnectedClients = {};
-    const oSubscribedClients = {};
+    /**
+     * @typedef {string} ClientId
+     * The client id of the sender.
+     *
+     * @since 1.110.0
+     * @private
+     */
+
+    /**
+     * @typedef {string} ChannelId
+     * The channel id.
+     *
+     * @since 1.110.0
+     * @private
+     */
+
+    /**
+     * @typedef {object} ClientChannelData
+     * The internal representation of a client within a channel.
+     * @property {ClientId} clientId The client id.
+     * @property {sap.ushell.services.MessageBroker.MessageCallback} messageCallback
+     * The callback function that is called when a message is published to the channel.
+     *
+     * @since 1.110.0
+     * @private
+     */
+
+    /**
+     * @typedef {object} ClientSubscriptionData
+     * The internal representation of a client.
+     * @property {ClientId} clientId The client id.
+     * @property {sap.ushell.services.MessageBroker.Channel[]} channels The channels the client is subscribed to.
+     * @property {sap.ushell.services.MessageBroker.ClientConnectionCallback} clientConnectionCallback
+     * The callback function that is called when the client connects or disconnects.
+     *
+     * @since 1.110.0
+     * @private
+     */
+
+    /**
+     * @alias sap.ushell.services.MessageBroker.MessageBrokerEngine
+     * @namespace
+     * @description The Message Broker Engine is responsible for managing clients, channels, and messages.
+     *
+     * @since 1.110.0
+     * @private
+     */
+    class MessageBrokerEngine {
+        #bEnabled = true;
+        #bSkipEmitInformAboutOtherClients = false;
+        #oLogger = Log.getLogger("sap.ushell.services.MessageBroker");
 
-    // add default origin
-    oAcceptedOrigins[window.location.origin] = true;
+        /**
+         * @type {Set<string>} Set of accepted origins.
+         */
+        #sAcceptedOrigins = new Set();
 
-    function MessageBrokerEngine () {
-        this.setEnabled = function (bVal) {
-            bEnabled = bVal;
-        };
+        /**
+         * @type {Set<ClientId>} Set of connected clients.
+         */
+        #sConnectedClients = new Set();
 
         /**
-         *
-         * @param {object} oPostMessageData The PostMessage object.
-         * @returns {Promise} Promise result.
+         * @type {Object<ClientId, ClientSubscriptionData>} Map of subscribed clients.
+         */
+        #oSubscribedClients = {};
+
+        /**
+         * @type {Object<ChannelId, ClientChannelData[]>} Map of clients per channel.
+         * Key is the channel id, value is an array of clients subscribed to the channel.
+         */
+        #oClientsPerChannel = {};
+
+        #aPendingTimeouts = [];
+
+        constructor () {
+            // add default origin
+            this.addAcceptedOrigin(window.location.origin);
+        }
+
+        setEnabled (bVal) {
+            this.#bEnabled = bVal;
+        }
+
+        /**
+         * Connects the client to the message broker.
+         * When the client connects, it will receive the information about all other clients that are already subscribed to channels.
+         * Additionally, the client is informed about _any_ new subscription and unsubscription to a channel.
+         * @param {ClientId} sClientId client id.
+         * @param {sap.ushell.services.MessageBroker.ClientConnectionCallback} fnClientConnectionCallback
+         * Callback function that is called whenever the client subscribes or unsubscribes to a channel.
+         * @returns {Promise} Resolves once the client is connected.
          *
          * @since 1.110.0
          * @private
          */
+        async connect (sClientId, fnClientConnectionCallback) {
+            if (!this.#bEnabled) {
+                throw new Error(`Cannot connect client '${sClientId}': MessageBroker is not enabled`);
+            }
 
-        this.processPostMessage = function (oPostMessageData) {
-            if (!bEnabled) {
-                return Promise.reject();
+            if (typeof sClientId !== "string" || !sClientId.length) {
+                throw new Error("Cannot connect client: Missing required parameter client id");
             }
 
-            const oMessageData = oPostMessageData.oMessageData;
-            const oMessageDataBody = oMessageData.body;
-            const oMessage = oPostMessageData.oMessage;
-            const sOrigin = oMessage.origin;
-            const oIframe = oMessage.source;
+            if (this.#sConnectedClients.has(sClientId)) {
+                throw new Error(`Cannot connect client '${sClientId}': Client is already connected`);
+            }
 
-            oMessageDataBody.requestId = oMessageData.request_id;
+            if (
+                typeof fnClientConnectionCallback !== "function"
+            ) {
+                this.#oLogger.error(`Missing required parameter 'fnClientConnectionCallback' for client '${sClientId}'! It has to be provided as part of the connect() call`);
+            } else {
+                // add client connection callback
+                this.#oSubscribedClients[sClientId] = {
+                    clientId: sClientId,
+                    channels: [],
+                    clientConnectionCallback: fnClientConnectionCallback
+                };
 
-            if (!oIframe) {
-                const sErrorMsg = "Missing iframe object in PostMessage request";
-                Log.error(sErrorMsg, null, "sap.ushell.services.MessageBroker");
-                return Promise.reject(sErrorMsg);
+                this.#aPendingTimeouts.push(setTimeout(() => {
+                    this.#emitInformAboutOtherClients(sClientId);
+                }, 0));
             }
 
-            return this._handlePostMessageRequest(oMessageDataBody, oIframe, sOrigin);
-        };
+            // add client initial entry to connected clients
+            this.#sConnectedClients.add(sClientId);
+        }
 
         /**
+         * Emits information about all other clients to the specified client.
+         * @param {ClientId} sClientId client id.
          *
-         * @param {string} sClientId client id.
-         * @returns {Promise} the result.
-         *
-         * @since 1.110.0
+         * @since 1.140.0
          * @private
          */
-
-        this.connect = function (sClientId) {
-            let sError;
-
-            if (!bEnabled) {
-                return Promise.reject();
+        #emitInformAboutOtherClients (sClientId) {
+            // ONLY FOR TESTING!
+            if (this.#bSkipEmitInformAboutOtherClients) {
+                return;
             }
 
-            if (typeof sClientId !== "string" || !sClientId.length) {
-                sError = "Missing required parameter client id";
-            } else if (oConnectedClients[sClientId]) {
-                sError = "Client is already connected";
-            } else {
-                // add client initial entry to connected clients
-                oConnectedClients[sClientId] = true;
-                return Promise.resolve();
+            const oClient = this.#oSubscribedClients[sClientId];
+            if (!oClient) {
+                // client is already disconnected
+                return;
             }
 
-            Log.error(sError, null, "sap.ushell.services.MessageBroker");
-            return Promise.reject(sError);
-        };
+            const aOtherSubscribedClients = Object.values(this.#oSubscribedClients).filter((oOtherClient) => {
+                return oOtherClient.clientId !== sClientId;
+            });
+
+            if (aOtherSubscribedClients.length) {
+                aOtherSubscribedClients.forEach((oOtherClient) => {
+                    oClient.clientConnectionCallback(
+                        ClientConnectionMessage.ClientSubscribed,
+                        oOtherClient.clientId,
+                        deepClone(oOtherClient.channels)
+                    );
+                });
+            }
+        }
 
         /**
-         *
-         * @param {string} sClientId client id.
-         * @returns {Promise} the result.
+         * Disconnects the client.
+         * If the client was subscribed to channels, it will be unsubscribed from all channels.
+         * @param {ClientId} sClientId client id.
+         * @returns {Promise} Resolves once the client is disconnected.
          *
          * @since 1.110.0
          * @private
          */
-
-        this.disconnect = function (sClientId) {
-            let sError;
-
-            if (!bEnabled) {
-                return Promise.reject();
+        async disconnect (sClientId) {
+            if (!this.#bEnabled) {
+                throw new Error(`Cannot disconnect client '${sClientId}': MessageBroker is not enabled`);
             }
 
             if (typeof sClientId !== "string" || !sClientId.length) {
-                sError = "Missing required parameter client id";
-            } else if (!oConnectedClients[sClientId]) {
-                sError = "Client is already disconnected";
-            } else {
-                for (const sChannelKey in oClientsPerChannel) {
-                    const aChannelClients = oClientsPerChannel[sChannelKey];
-                    // find client and remove from the channel
-                    for (const oClientKey in aChannelClients) {
-                        const oClient = aChannelClients[oClientKey];
+                throw new Error("Cannot disconnect client: Missing required parameter client id");
+            }
+            if (!this.#sConnectedClients.has(sClientId)) {
+                throw new Error(`Cannot disconnect client '${sClientId}': Client is already disconnected`);
+            }
 
-                        if (oClient.clientId === sClientId) {
-                            aChannelClients.splice(oClientKey, 1);
-                            break;
-                        }
-                    }
-                }
+            // === Update "channel data" ===
+            for (const sChannelId in this.#oClientsPerChannel) {
+                // find client and remove from the channel
+                this.#oClientsPerChannel[sChannelId] = this.#oClientsPerChannel[sChannelId].filter((oClient) => {
+                    return oClient.clientId !== sClientId;
+                });
+            }
 
+            // === Update "subscribed clients" ===
+            if (this.#oSubscribedClients[sClientId]?.channels.length) {
                 // if client disconnects but is still subscribed
-                if (oSubscribedClients[sClientId] && oSubscribedClients[sClientId].channels.length) {
-                    this._emitEvent("clientUnsubscribed", sClientId, oSubscribedClients[sClientId].channels);
-
-                    // remove from subscribed clients
-                    delete oSubscribedClients[sClientId];
-                }
-                // remove from connected clients
-                delete oConnectedClients[sClientId];
-
-                return Promise.resolve();
+                this.#emitConnectionEvent(
+                    ClientConnectionMessage.ClientUnsubscribed,
+                    sClientId,
+                    this.#oSubscribedClients[sClientId].channels
+                );
             }
+            // remove from subscribed clients
+            delete this.#oSubscribedClients[sClientId];
 
-            Log.error(sError, null, "sap.ushell.services.MessageBroker");
-            return Promise.reject(sError);
-        };
+            // remove from connected clients
+            this.#sConnectedClients.delete(sClientId);
+        }
 
         /**
-         *
-         * @param {string} sClientId client id.
-         * @param {Array<*>} aSubscribedChannels array of channel-objects.
-         * @param {function} fnMessageCallback callback function returns promise.
-         * @param {function} fnClientConnectionCallback callback function returns promise.
-         * @param {object} oIframe iframe object if iframe client.
-         * @param {string} sOrigin iframe origin if iframe client.
-         * @returns {Promise} the result.
+         * Subscribe to a channel.
+         * Before subscribing, the client must be connected.
+         * Afterwards, the client receives messages for the subscribed channels.
+         * @param {ClientId} sClientId client id.
+         * @param {sap.ushell.services.MessageBroker.Channel[]} aSubscribedChannels array of channel-objects.
+         * @param {sap.ushell.services.MessageBroker.MessageCallback} fnMessageCallback
+         * Callback function that is called whenever a message is published to subscribed channels.
+         * The message callback is overwritten on subsequent calls to subscribe.
+         * Every channel can has its own message callback.
+         * @param {sap.ushell.services.MessageBroker.ClientConnectionCallback} fnClientConnectionCallback
+         * <b>DEPRECATED</b> Should be provided as part of {@link #connect}.
+         * @returns {Promise} Resolves once the client is subscribed to the channels.
          *
          * @since 1.110.0
          * @private
          */
-
-        this.subscribe = function (sClientId, aSubscribedChannels, fnMessageCallback, fnClientConnectionCallback, oIframe, sOrigin) {
-            let sError;
-            const sMessageName = "clientSubscribed";
-            let aOtherSubscribedClients = [];
-            let bIsNewClient = false;
-
-            if (!bEnabled) {
-                return Promise.reject();
+        async subscribe (sClientId, aSubscribedChannels, fnMessageCallback, fnClientConnectionCallback) {
+            if (!this.#bEnabled) {
+                throw new Error(`Cannot subscribe client '${sClientId}': MessageBroker is not enabled`);
             }
 
-            if (typeof sClientId !== "string" || !sClientId.length ||
-                !aSubscribedChannels.length ||
-                (typeof oIframe !== "object" &&
-                    (typeof fnMessageCallback !== "function" ||
-                        typeof fnClientConnectionCallback !== "function"))) {
-                sError = "Missing required parameter(s)";
-            } else if (!oConnectedClients[sClientId]) {
-                sError = "Client is not connected";
-            } else {
-                for (const sChannelKey in aSubscribedChannels) {
-                    const oChannel = aSubscribedChannels[sChannelKey];
-
-                    // add new client to the channel
-                    const oFullClientData = {
-                        clientId: sClientId,
-                        subscribedChannels: aSubscribedChannels,
-                        messageCallback: fnMessageCallback,
-                        clientConnectionCallback: fnClientConnectionCallback,
-                        iframe: oIframe || {},
-                        origin: sOrigin || "",
-                        isUI5: !oIframe
-                    };
-
-                    // add new channel
-                    if (!oClientsPerChannel[oChannel.channelId]) {
-                        oClientsPerChannel[oChannel.channelId] = [];
-                    }
-
-                    const oExistingClient = oClientsPerChannel[oChannel.channelId].find((oClient) => {
-                        return oClient.clientId === sClientId;
-                    });
+            if (
+                typeof sClientId !== "string"
+                || !sClientId.length
+                || !aSubscribedChannels.length
+                || typeof fnMessageCallback !== "function"
+            ) {
+                throw new Error(`Cannot subscribe client '${sClientId}': Missing required parameter(s)`);
+            }
 
-                    // add new client
-                    if (!oExistingClient) {
-                        oClientsPerChannel[oChannel.channelId].push(oFullClientData);
-                    }
+            if (
+                typeof fnClientConnectionCallback === "function"
+            ) {
+                // eslint-disable-next-line max-len
+                this.#oLogger.error(`The 'fnClientConnectionCallback' parameter was provided by client '${sClientId}'. This parameter is deprecated and should be provided as part of the connect() call`);
+            }
 
-                    // if client is already subscribed to any channel
-                    if (oSubscribedClients[sClientId]) {
-                        const oExistingChannel = oSubscribedClients[sClientId].channels.find((oSubChannel) => {
-                            return oSubChannel.channelId === oChannel.channelId;
-                        });
+            if (!this.#sConnectedClients.has(sClientId)) {
+                throw new Error(`Cannot subscribe client '${sClientId}': Client is not connected`);
+            }
 
-                        if (!oExistingChannel) {
-                            // add new channel to the existing channels
-                            oSubscribedClients[sClientId].channels.push(oChannel);
-                        }
-                    }
+            // === Update "channel data" ===
+            for (const oChannel of aSubscribedChannels) {
+                const sChannelId = oChannel.channelId;
+                // add new channel
+                if (!this.#oClientsPerChannel[sChannelId]) {
+                    this.#oClientsPerChannel[sChannelId] = [];
                 }
 
-                // if new client
-                if (!oSubscribedClients[sClientId]) {
-                    bIsNewClient = true;
+                const oClientChannelData = this.#oClientsPerChannel[sChannelId].find((oClient) => {
+                    return oClient.clientId === sClientId;
+                });
 
-                    const oSubscriptionData = {
+                // add new client
+                if (!oClientChannelData) {
+                    // add new client to the channel
+                    this.#oClientsPerChannel[sChannelId].push({
                         clientId: sClientId,
-                        channels: aSubscribedChannels
-                    };
-                    // add to subscribed clients
-                    oSubscribedClients[sClientId] = oSubscriptionData;
-
-                    aOtherSubscribedClients = Object.values(oSubscribedClients).filter((oClient) => {
-                        return oClient.clientId !== sClientId;
+                        messageCallback: fnMessageCallback
                     });
+                } else {
+                    oClientChannelData.messageCallback = fnMessageCallback;
                 }
+            }
 
-                // notify other subscribed clients of new subscription
-                if (Object.keys(oSubscribedClients).length > 1) {
-                    this._emitEvent(sMessageName, sClientId, aSubscribedChannels);
-                }
+            // === Update "subscribed clients" ===
+            const oClientSubscriptionData = this.#oSubscribedClients[sClientId];
+            if (!oClientSubscriptionData) { // this case is deprecated as all clients should be connected and provide the connection callback before
+                // add to subscribed clients
+                this.#oSubscribedClients[sClientId] = {
+                    clientId: sClientId,
+                    channels: deepClone(aSubscribedChannels),
+                    clientConnectionCallback: fnClientConnectionCallback
+                };
 
-                if (bIsNewClient) {
-                    // notify new client of other already subscribed clients
-                    setTimeout(() => {
-                        if (aOtherSubscribedClients.length) {
-                            aOtherSubscribedClients.forEach((oClient) => {
-                                if (!oIframe) {
-                                    fnClientConnectionCallback(sMessageName, oClient.clientId, oClient.channels);
-                                } else {
-                                    const oParams = {
-                                        clientId: oClient.clientId,
-                                        channels: oClient.channels,
-                                        channelId: "sap.ushell.MessageBroker",
-                                        messageName: sMessageName
-                                    };
-
-                                    sap.ui.require(["sap/ushell/appIntegration/PostMessageManager"], (PostMessageManager) => {
-                                        const oResult = this._buildPostMessageObject("event", oParams);
-                                        this._sendPostMessage(PostMessageManager, oResult, oIframe, sOrigin);
-                                    });
-                                }
-                            });
-                        }
-                    }, 1000);
-                }
+                // notify new client of other already subscribed clients
+                this.#aPendingTimeouts.push(setTimeout(() => {
+                    this.#emitInformAboutOtherClients(sClientId);
+                }, 1000));
+            } else {
+                // if client is already subscribed to any channel
+                for (const oChannel of aSubscribedChannels) {
+                    const bAlreadySubscribed = oClientSubscriptionData.channels.some((oSubChannel) => {
+                        return oSubChannel.channelId === oChannel.channelId;
+                    });
 
-                return Promise.resolve();
+                    if (!bAlreadySubscribed) {
+                        // add new channel to the existing channels
+                        oClientSubscriptionData.channels.push(oChannel);
+                    }
+                }
             }
 
-            Log.error(sError, null, "sap.ushell.services.MessageBroker");
-            return Promise.reject(sError);
-        };
+            // notify other subscribed clients of new subscription
+            if (Object.keys(this.#oSubscribedClients).length > 1) {
+                this.#emitConnectionEvent(
+                    ClientConnectionMessage.ClientSubscribed,
+                    sClientId,
+                    aSubscribedChannels
+                );
+            }
+        }
 
         /**
-         *
-         * @param {string} sClientId client id.
-         * @param {object[]} aUnsubscribedChannels channels to unsubscribe from.
-         * @returns {Promise} the resolve or error.
+         * Unsubscribes the client from the specified channels.
+         * @param {ClientId} sClientId client id.
+         * @param {sap.ushell.services.MessageBroker.Channel[]} aUnsubscribedChannels channels to unsubscribe from.
+         * @returns {Promise} Resolves once the client is unsubscribed from the channels.
          *
          * @since 1.110.0
          * @private
          */
-
-        this.unsubscribe = function (sClientId, aUnsubscribedChannels) {
-            let sError;
-
-            if (!bEnabled) {
-                return Promise.reject();
+        async unsubscribe (sClientId, aUnsubscribedChannels) {
+            if (!this.#bEnabled) {
+                throw new Error(`Cannot unsubscribe client '${sClientId}': MessageBroker is not enabled`);
             }
 
-            if (typeof sClientId !== "string" || !sClientId.length ||
-                !Array.isArray(aUnsubscribedChannels) || !aUnsubscribedChannels.length) {
-                sError = "Missing required parameter(s)";
-                Log.error(sError, null, "sap.ushell.services.MessageBroker");
-                return Promise.reject(sError);
+            if (
+                typeof sClientId !== "string"
+                || !sClientId.length
+                || !Array.isArray(aUnsubscribedChannels)
+                || !aUnsubscribedChannels.length
+            ) {
+                throw new Error(`Cannot unsubscribe client '${sClientId}': Missing required parameter(s)`);
             }
 
-            if (!oConnectedClients[sClientId]) {
-                sError = "Client is not connected";
-                Log.error(sError, null, "sap.ushell.services.MessageBroker");
-                return Promise.reject(sError);
+            if (!this.#sConnectedClients.has(sClientId)) {
+                throw new Error(`Cannot unsubscribe client '${sClientId}': Client is not connected`);
             }
 
-            for (const sChannelIndex in aUnsubscribedChannels) {
-                const oChannel = aUnsubscribedChannels[sChannelIndex];
-
-                if (oClientsPerChannel[oChannel.channelId]) {
-                    const aChannelClients = oClientsPerChannel[oChannel.channelId];
+            // === Update "channel data" ===
+            for (const oChannel of aUnsubscribedChannels) {
+                const sChannelId = oChannel.channelId;
+                if (this.#oClientsPerChannel[sChannelId]) {
                     // find client and remove from the channel
-                    for (const oClientKey in aChannelClients) {
-                        const oClient = aChannelClients[oClientKey];
-
-                        if (oClient.clientId === sClientId) {
-                            const aSubscribedChannels = oSubscribedClients[sClientId].channels;
-
-                            oSubscribedClients[sClientId].channels = aSubscribedChannels.filter((oSubChannel) => {
-                                return oSubChannel.channelId !== oChannel.channelId;
-                            });
-
-                            aChannelClients.splice(oClientKey, 1);
-                            break;
-                        }
-                    }
+                    this.#oClientsPerChannel[sChannelId] = this.#oClientsPerChannel[sChannelId].filter((oClient) => {
+                        return oClient.clientId !== sClientId;
+                    });
                 } else {
                     // if channel does not exist
-                    const sMessage = `Unknown channel Id: ${oChannel.channelId}`;
-                    Log.warning(sMessage, null, "sap.ushell.services.MessageBroker");
+                    this.#oLogger.warning(`Cannot unsubscribe client '${sClientId}': Channel '${sChannelId}' is unknown`);
                 }
             }
 
-            this._emitEvent("clientUnsubscribed", sClientId, aUnsubscribedChannels);
-            return Promise.resolve();
-        };
+            // === Update "subscribed clients" ===
+            this.#oSubscribedClients[sClientId].channels = this.#oSubscribedClients[sClientId].channels.filter((oChannel) => {
+                const bFound = aUnsubscribedChannels.some((oChannelToRemove) => {
+                    return oChannelToRemove.channelId === oChannel.channelId;
+                });
+                return !bFound;
+            });
+
+            this.#emitConnectionEvent(
+                ClientConnectionMessage.ClientUnsubscribed,
+                sClientId,
+                aUnsubscribedChannels
+            );
+        }
 
         /**
-         *
-         * @param {string} sChannelId channel id.
-         * @param {string} sClientId client id.
-         * @param {string} sMessageId request id for iframe clients or message id for UI5 clients.
-         * @param {string} sMessageName message name.
-         * @param {string[]} aTargetClientIds array of target clients Ids.
-         * @param {object} data additional data.
-         * @returns {Promise} Promise result.
+         * Publishes a message to a channel.
+         * All clients that are subscribed to the channel will receive the message.
+         * The message is NOT sent to the client that published it.
+         *
+         * @param {ChannelId} sChannelId channel id.
+         * @param {ClientId} sClientId The client id of the sender.
+         * @param {string} sMessageId
+         * <b>DEPRECATED</b> Should not be provided.
+         * @param {string} sMessageName message name. Can be used to identify the message type or as a topic.
+         * @param {string[]|sap.ushell.services.MessageBroker.ClientAlias.AllClients} vTargetClientIds
+         * list of target client ids. Can include the wildcard "*" to send the message to all clients subscribed to the channel.
+         * If the wildcard is used, the other client ids are ignored.
+         * @param {object} oData additional data.
+         * @returns {Promise} Resolves once the message is published successfully.
          *
          * @since 1.110.0
          * @private
          */
+        async publish (sChannelId, sClientId, sMessageId, sMessageName, vTargetClientIds, oData) {
+            if (!this.#bEnabled) {
+                throw new Error(`Cannot publish message of client '${sClientId}': MessageBroker is not enabled`);
+            }
 
-        this.publish = function (sChannelId, sClientId, sMessageId, sMessageName, aTargetClientIds, data) {
-            let sError;
-            let aTargetClients = [];
+            if (typeof sMessageName === "string" && (Array.isArray(vTargetClientIds) || vTargetClientIds === ClientAlias.AllClients)) {
+                this.#oLogger.error(`The parameter 'sMessageId' was provided by client '${sClientId}'. It is deprecated and should not be provided`);
+            } else {
+                // do remapping
+                oData = vTargetClientIds;
+                vTargetClientIds = sMessageName;
+                sMessageName = sMessageId;
+                sMessageId = undefined;
+            }
 
-            if (!bEnabled) {
-                return Promise.reject();
+            let aTargetClientIds;
+            if (vTargetClientIds === ClientAlias.AllClients) {
+                aTargetClientIds = [ClientAlias.AllClients];
+            } else {
+                aTargetClientIds = [...vTargetClientIds];
             }
 
             // if client is not connected
-            if (!oConnectedClients[sClientId]) {
-                sError = "Client is not connected";
-                Log.error(sError, null, "sap.ushell.services.MessageBroker");
-                return Promise.reject(sError);
+            if (!this.#sConnectedClients.has(sClientId)) {
+                throw new Error(`Cannot publish message '${sMessageName}' of client '${sClientId}': Client '${sClientId}' is not connected`);
             }
 
             // if channel does not exist
-            if (!oClientsPerChannel[sChannelId]) {
-                sError = `Unknown channel Id: ${sChannelId}`;
-                Log.error(sError, null, "sap.ushell.services.MessageBroker");
-                return Promise.reject(sError);
+            if (!this.#oClientsPerChannel[sChannelId]) {
+                throw new Error(`Cannot publish message '${sMessageName}' of client '${sClientId}': Channel '${sChannelId}' is unknown`);
             }
 
-            const oPubClient = oClientsPerChannel[sChannelId].find((oSubClient) => {
+            const aSubscribedClients = this.#oClientsPerChannel[sChannelId];
+            const oPublishingClient = aSubscribedClients.find((oSubClient) => {
                 return oSubClient.clientId === sClientId;
             });
 
             // if client is not subscribed to the channel
-            if (!oPubClient) {
-                sError = "Client is not subscribed to the provided channel";
-                Log.error(sError, null, "sap.ushell.services.MessageBroker");
-                return Promise.reject(sError);
+            if (!oPublishingClient) {
+                throw new Error(`Cannot publish message '${sMessageName}' of client '${sClientId}': Client is not subscribed to the provided channel '${sChannelId}'`);
             }
 
-            for (const sClientKey in aTargetClientIds) {
-                const sTargetClientId = aTargetClientIds[sClientKey];
+            const bUsesWildcard = aTargetClientIds.includes(ClientAlias.AllClients);
 
-                // if message is for all clients in the channel
-                if (sTargetClientId === "*") {
-                    aTargetClients = oClientsPerChannel[sChannelId].concat();
-                    break;
-                } else {
+            let aTargetClients = [];
+            if (bUsesWildcard) {
+                aTargetClients = [...aSubscribedClients];
+            } else {
+                for (const sTargetClientId of aTargetClientIds) {
                     // check if target client exists
-                    const oTargetClient = oClientsPerChannel[sChannelId].find((oClient) => {
+                    const oClientChannelData = aSubscribedClients.find((oClient) => {
                         return oClient.clientId === sTargetClientId;
                     });
 
-                    if (oTargetClient) {
-                        aTargetClients.push(this._deepCopy(oTargetClient));
+                    if (oClientChannelData) {
+                        aTargetClients.push(oClientChannelData);
                     }
                 }
             }
 
-            if (aTargetClients.length) {
-                this._sendMessage(aTargetClients, sChannelId, sMessageId, sMessageName, sClientId, data);
-                return Promise.resolve();
+            if (!bUsesWildcard && !aTargetClients.length) {
+                throw new Error(`Cannot publish message '${sMessageName}' of client '${sClientId}': No target client(s) found in the provided channel '${sChannelId}'`);
             }
 
-            sError = "Target client(s) not found in the provided channel";
-            Log.error(sError, null, "sap.ushell.services.MessageBroker");
-            return Promise.reject(sError);
-        };
+            this.#sendMessage(aTargetClients, sChannelId, sMessageName, sClientId, oData);
+        }
 
         /**
+         * Adds the iframe origin to the list of accepted origins.
+         * The port is automatically added based on the protocol (HTTP/HTTPS).
          *
-         * @param {string} sOrigin iframe origin.
+         * @param {string} sOrigin The iframe origin (e.g https://www.example.com:443)
          *
          * @since 1.110.0
          * @private
          */
-
-        this.addAcceptedOrigin = function (sOrigin) {
-            if (!bEnabled) {
+        addAcceptedOrigin (sOrigin) {
+            if (!this.#bEnabled) {
                 return;
             }
 
-            if (typeof sOrigin === "string" && sOrigin.length > 0) {
-                oAcceptedOrigins[sOrigin] = true;
-                if (sOrigin.startsWith("https:") && sOrigin.endsWith(":443")) {
-                    oAcceptedOrigins[sOrigin.substring(0, sOrigin.length - 4)] = true;
+            if (typeof sOrigin !== "string" || !sOrigin.length) {
+                throw new Error("Missing required parameter");
+            }
+
+            this.#sAcceptedOrigins.add(sOrigin);
+            const oUrl = new URL(sOrigin);
+
+            if (oUrl.protocol === "https:" && oUrl.port === "") {
+                // store the origin with and without port
+                if (sOrigin.endsWith(":443")) {
+                    this.#sAcceptedOrigins.add(sOrigin.substring(0, sOrigin.length - 4));
+                } else {
+                    this.#sAcceptedOrigins.add(`${sOrigin}:443`);
                 }
-            } else {
-                Log.warning("Missing required parameter sOrigin", null, "sap.ushell.services.MessageBroker");
             }
-        };
+            if (oUrl.protocol === "http:" && oUrl.port === "") {
+                // store the origin with and without port
+                if (sOrigin.endsWith(":80")) {
+                    this.#sAcceptedOrigins.add(sOrigin.substring(0, sOrigin.length - 3));
+                } else {
+                    this.#sAcceptedOrigins.add(`${sOrigin}:80`);
+                }
+            }
+        }
 
         /**
+         * Removes the iframe origin from the list of accepted origins.
+         * Also removes the origin with or without port based on the protocol (HTTP/HTTPS).
          *
-         * @param {string} sOrigin iframe origin.
+         * @param {string} sOrigin The iframe origin (e.g https://www.example.com:443)
          *
          * @since 1.110.0
          * @private
          */
-
-        this.removeAcceptedOrigin = function (sOrigin) {
-            if (!bEnabled) {
+        removeAcceptedOrigin (sOrigin) {
+            if (!this.#bEnabled) {
                 return;
             }
-            delete oAcceptedOrigins[sOrigin];
-        };
+
+            if (typeof sOrigin !== "string" || !sOrigin.length) {
+                throw new Error("Missing required parameter");
+            }
+
+            this.#sAcceptedOrigins.delete(sOrigin);
+            const oUrl = new URL(sOrigin);
+
+            if (oUrl.protocol === "https:" && oUrl.port === "") {
+                // remove the origin with and without port
+                if (sOrigin.endsWith(":443")) {
+                    this.#sAcceptedOrigins.delete(sOrigin.substring(0, sOrigin.length - 4));
+                } else {
+                    this.#sAcceptedOrigins.delete(`${sOrigin}:443`);
+                }
+            }
+            if (oUrl.protocol === "http:" && oUrl.port === "") {
+                // remove the origin with and without port
+                if (sOrigin.endsWith(":80")) {
+                    this.#sAcceptedOrigins.delete(sOrigin.substring(0, sOrigin.length - 3));
+                } else {
+                    this.#sAcceptedOrigins.delete(`${sOrigin}:80`);
+                }
+            }
+        }
 
         /**
-         *
-         * @returns {string[]} the result.
+         * Returns the current list of accepted origins.
+         * @returns {string[]} The list of accepted origins.
          *
          * @since 1.110.0
          * @private
          */
-
-        this.getAcceptedOrigins = function () {
-            if (!bEnabled) {
+        getAcceptedOrigins () {
+            if (!this.#bEnabled) {
                 return;
             }
-            return Object.keys(oAcceptedOrigins);
-        };
+            return Array.from(this.#sAcceptedOrigins.values());
+        }
 
         /**
-         *
+         * Returns the map of subscribed clients.
          * @returns {object} the result.
          *
          * @since 1.110.0
          * @private
          */
-
-        this.getSubscribedClients = function () {
-            if (!bEnabled) {
+        getSubscribedClients () {
+            if (!this.#bEnabled) {
                 return;
             }
-            return this._deepCopy(oClientsPerChannel);
-        };
+            return deepClone(this.#oClientsPerChannel);
+        }
 
         /**
+         * Calls the connection callback for all subscribed clients except the one who initiated the event.
          *
-         * @param {string} sMessageName message name.
-         * @param {string} sClientId client id.
-         * @param {Array<*>} aChannels subscribed/unsubscribed channels of the client.
+         * @param {sap.ushell.services.MessageBroker.ClientConnectionMessage} sMessageName The event to emit.
+         * @param {ClientId} sClientId The client id of the sender.
+         * @param {sap.ushell.services.MessageBroker.Channel[]} aChannels subscribed/unsubscribed channels of the client.
          *
          * @since 1.110.0
          * @private
          */
-
-        this._emitEvent = function (sMessageName, sClientId, aChannels) {
-            const oNotifiedClients = {};
-
-            for (const sChannelKey in oClientsPerChannel) {
-                const oChannel = oClientsPerChannel[sChannelKey];
-
-                for (const sClientKey in oChannel) {
-                    const oClient = oChannel[sClientKey];
-                    // do not notify the same client who initiated the event
-                    if (oClient.clientId !== sClientId && !oNotifiedClients[oClient.clientId]) {
-                        const oParams = {
-                            clientId: sClientId,
-                            channels: aChannels
-                        };
-
-                        if (oClient.isUI5 !== false) {
-                            oClient.clientConnectionCallback(sMessageName, sClientId, aChannels);
-                        } else {
-                            oParams.channelId = "sap.ushell.MessageBroker";
-                            oParams.messageName = sMessageName;
-
-                            sap.ui.require(["sap/ushell/appIntegration/PostMessageManager"], (PostMessageManager) => {
-                                const oResult = this._buildPostMessageObject("event", oParams);
-                                this._sendPostMessage(PostMessageManager, oResult, oClient.iframe, oClient.origin);
-                            });
-                        }
-
-                        oNotifiedClients[oClient.clientId] = true;
-                    }
+        #emitConnectionEvent (sMessageName, sClientId, aChannels) {
+            for (const oClient of Object.values(this.#oSubscribedClients)) {
+                // do not notify the same client who initiated the event
+                if (oClient.clientId !== sClientId) {
+                    oClient.clientConnectionCallback(sMessageName, sClientId, deepClone(aChannels));
                 }
             }
-        };
+        }
 
         /**
+         * Calls the message callback for all target clients except the one who initiated the event.
          *
-         * @param {object[]} aTargetClients target clients.
-         * @param {string} sChannelId channel id.
-         * @param {string} sMessageId request id for iframe clients or message id for UI5 clients.
-         * @param {string} sMessageName message name.
-         * @param {string} sClientId client id.
-         * @param {object} data additional data.
+         * @param {ClientChannelData[]} aTargetClients target clients.
+         * @param {ChannelId} sChannelId The channel id.
+         * @param {string} sMessageName The message name.
+         * @param {ClientId} sClientId The client id of the sender.
+         * @param {object} oData Additional data.
          *
          * @since 1.110.0
          * @private
          */
-
-        this._sendMessage = function (aTargetClients, sChannelId, sMessageId, sMessageName, sClientId, data) {
-            for (const sClientKey in aTargetClients) {
-                const oClient = aTargetClients[sClientKey];
-
+        #sendMessage (aTargetClients, sChannelId, sMessageName, sClientId, oData) {
+            for (const oClient of aTargetClients) {
                 // do not send message to the same client who requested to send it
                 if (oClient.clientId !== sClientId) {
-                    if (oClient.isUI5 !== false) {
-                        oClient.messageCallback(sClientId, sChannelId, sMessageName, data);
-                    } else {
-                        const oParams = {
-                            clientId: sClientId,
-                            channelId: sChannelId,
-                            messageName: sMessageName,
-                            data: data
-                        };
-
-                        sap.ui.require(["sap/ushell/appIntegration/PostMessageManager"], (PostMessageManager) => {
-                            const oResult = this._buildPostMessageObject("request", oParams);
-                            this._sendPostMessage(PostMessageManager, oResult, oClient.iframe, oClient.origin);
-                        });
-                    }
+                    oClient.messageCallback(sClientId, sChannelId, sMessageName, deepClone(oData));
                 }
             }
-        };
-
-        /**
-         *
-         * @param {string} sEndpoint api method name.
-         * @param {Array<*>} aParams api parameters.
-         * @returns {Promise} Promise result.
-         *
-         * @since 1.110.0
-         * @private
-         */
-
-        this._callApi = function (sEndpoint, aParams) {
-            return this[sEndpoint].apply(this, aParams);
-        };
+        }
 
         /**
-         * @param {object} oMessageDataBody message object.
-         * @param {object} oIframe The iFrame object.
-         * @param {string} sOrigin iframe origin.
-         * @returns {Promise} Promise result.
+         * ONLY FOR TESTING!
+         * Resets the Message Broker Engine.
          *
-         * @since 1.110.0
+         * @since 1.140.0
          * @private
          */
+        reset () {
+            // Reset all internal states
+            this.#bEnabled = true;
+            this.#bSkipEmitInformAboutOtherClients = false;
 
-        this._handlePostMessageRequest = function (oMessageDataBody, oIframe, sOrigin) {
-            return new Promise((resolve, reject) => {
-                const sClientId = oMessageDataBody.clientId;
-                const sChannelId = oMessageDataBody.channelId;
-                const sRequestId = oMessageDataBody.requestId;
-                let sMessageName = oMessageDataBody.messageName;
-                const aSubscribedChannels = oMessageDataBody.subscribedChannels;
-                const aTargetClientIds = oMessageDataBody.targetClientIds;
-                const data = oMessageDataBody.data;
-
-                const oApiParams = {
-                    connect: [
-                        sClientId
-                    ],
-                    disconnect: [
-                        sClientId
-                    ],
-                    subscribe: [
-                        sClientId,
-                        aSubscribedChannels,
-                        null,
-                        null,
-                        oIframe,
-                        sOrigin
-                    ],
-                    unsubscribe: [
-                        sClientId,
-                        aSubscribedChannels
-                    ],
-                    publish: [
-                        sChannelId,
-                        sClientId,
-                        sRequestId,
-                        sMessageName,
-                        aTargetClientIds,
-                        data
-                    ]
-                };
+            this.#sAcceptedOrigins.clear();
+            this.#sConnectedClients.clear();
+            this.#oSubscribedClients = {};
+            this.#oClientsPerChannel = {};
 
-                const oPostMessageParams = {
-                    channelId: sChannelId,
-                    clientId: sClientId,
-                    messageName: sMessageName,
-                    requestId: sRequestId
-                };
+            // Add default origin again
+            this.addAcceptedOrigin(window.location.origin);
 
-                sMessageName = oApiParams[sMessageName] ? sMessageName : "publish";
-
-                this._callApi(sMessageName, oApiParams[sMessageName])
-                    .then(() => {
-                        if (sMessageName !== "publish") {
-                            sap.ui.require(["sap/ushell/appIntegration/PostMessageManager"], (PostMessageManager) => {
-                                const oResult = this._buildPostMessageObject("response", oPostMessageParams);
-                                oResult.messageBody.status = "accepted";
-
-                                this._sendPostMessage(PostMessageManager, oResult, oIframe, sOrigin);
-                            });
-                        }
-                        resolve({ _noresponse_: true });
-                    }).catch((sError) => {
-                        reject(sError);
-                    });
+            this.#aPendingTimeouts.forEach((iTimeout) => {
+                clearTimeout(iTimeout);
             });
-        };
+            this.#aPendingTimeouts = [];
+        }
 
         /**
+         * ONLY FOR TESTING!
+         * Skips the emit of the "inform about other clients" event.
+         * This is useful for testing purposes to avoid sending messages to other clients.
          *
-         * @param {string} sType object type.
-         * @param {object} oParams object properties.
-         * @returns {object} relevant post message object.
-         *
-         * @since 1.110.0
+         * @since 1.140.0
          * @private
          */
-
-        this._buildPostMessageObjectFallback = function (PostMessageUtils, sObjectType, oParams) {
-            const sServiceName = "sap.ushell.services.MessageBroker";
-
-            if (sObjectType === "response") {
-                const oMessageBody = {
-                    channelId: oParams.channelId,
-                    clientId: oParams.clientId,
-                    correlationMessageId: oParams.requestId,
-                    messageName: oParams.messageName
-                };
-                const oResponse = PostMessageUtils.createPostMessageResponse(
-                    sServiceName,
-                    oParams.requestId,
-                    oMessageBody,
-                    true
-                );
-                return oResponse;
-            }
-
-            if (sObjectType === "event") {
-                const oMessageBody = {
-                    channelId: oParams.channelId,
-                    clientId: oParams.clientId,
-                    messageName: oParams.messageName,
-                    channels: oParams.channels
-                };
-                const oRequest = PostMessageUtils.createPostMessageRequest(
-                    sServiceName,
-                    oMessageBody
-                );
-                return oRequest;
-            }
-
-            if (sObjectType === "request") {
-                const oMessageBody = {
-                    channelId: oParams.channelId,
-                    clientId: oParams.clientId,
-                    messageName: oParams.messageName,
-                    data: oParams.data
-                };
-                const oRequest = PostMessageUtils.createPostMessageRequest(
-                    sServiceName,
-                    oMessageBody
-                );
-                return oRequest;
-            }
-
-            return PostMessageUtils.createPostMessageRequest(
-                sServiceName
-            );
-        };
-
-        /**
-         *
-         * @param {string} sType object type.
-         * @param {object} oParams object properties.
-         * @returns {object} relevant post message object.
-         *
-         * @since 1.134.0
-         * @private
-         */
-
-        this._buildPostMessageObject = function (sObjectType, oParams) {
-            const sServiceName = "sap.ushell.services.MessageBroker";
-
-            if (sObjectType === "response") {
-                const oMessageBody = {
-                    channelId: oParams.channelId,
-                    clientId: oParams.clientId,
-                    correlationMessageId: oParams.requestId,
-                    messageName: oParams.messageName
-                };
-                return {
-                    isRequest: false,
-                    requestId: oParams.requestId,
-                    isSuccess: true,
-                    serviceRequest: sServiceName,
-                    messageBody: oMessageBody
-                };
-            }
-
-            if (sObjectType === "event") {
-                const oMessageBody = {
-                    channelId: oParams.channelId,
-                    clientId: oParams.clientId,
-                    messageName: oParams.messageName,
-                    channels: oParams.channels
-                };
-                return {
-                    isRequest: true,
-                    serviceRequest: sServiceName,
-                    messageBody: oMessageBody
-                };
-            }
-
-            if (sObjectType === "request") {
-                const oMessageBody = {
-                    channelId: oParams.channelId,
-                    clientId: oParams.clientId,
-                    messageName: oParams.messageName,
-                    data: oParams.data
-                };
-                return {
-                    isRequest: true,
-                    serviceRequest: sServiceName,
-                    messageBody: oMessageBody
-                };
-            }
-
-            return {
-                isRequest: true,
-                serviceRequest: sServiceName
-            };
-        };
-
-        this._sendPostMessage = function (PostMessageManager, oResult, oContentWindow, sTargetOrigin) {
-            if (oResult.isRequest) {
-                PostMessageManager.sendRequest(
-                    oResult.serviceRequest,
-                    oResult.messageBody,
-                    oContentWindow,
-                    sTargetOrigin,
-                    false // bWaitForResponse
-                );
-            } else {
-                PostMessageManager.sendResponse(
-                    oResult.requestId,
-                    oResult.serviceRequest,
-                    oResult.messageBody,
-                    oResult.isSuccess,
-                    oContentWindow,
-                    sTargetOrigin
-                );
-            }
-        };
-
-        /**
-         *
-         * @param {string} sPrefix function name prefix.
-         * @param {string} sType function type.
-         * @returns {string} function name to call.
-         *
-         * @since 1.110.0
-         * @private
-         */
-
-        this._buildFunctionName = function (sPrefix, sType) {
-            sType = sType.charAt(0).toUpperCase() + sType.substring(1);
-            return sPrefix + sType;
-        };
-
-        /**
-         *
-         * @param {object} oEntity.
-         * @returns {object} deep copy.
-         *
-         * @since 1.110.0
-         * @private
-         */
-
-        this._deepCopy = function (oEntity) {
-            return deepExtend(oEntity);
-        };
-
-        this.reset = function () {
-            // Reset all internal states
-            bEnabled = true;
-            for (const sKey in oAcceptedOrigins) {
-                delete oAcceptedOrigins[sKey];
-            }
-            for (const sKey in oClientsPerChannel) {
-                delete oClientsPerChannel[sKey];
-            }
-            for (const sKey in oConnectedClients) {
-                delete oConnectedClients[sKey];
-            }
-            for (const sKey in oSubscribedClients) {
-                delete oSubscribedClients[sKey];
-            }
-
-            // Add default origin again
-            oAcceptedOrigins[window.location.origin] = true;
-        };
+        skipEmitInformAboutOtherClients () {
+            this.#bSkipEmitInformAboutOtherClients = true;
+        }
     }
 
     return new MessageBrokerEngine();
-}, false);
+});