@sapui5/sap.ushell 1.136.3 → 1.138.0

package/src/main/js/sap/ushell/EventHub.js

@@ -7,18 +7,10 @@
 
 sap.ui.define([
     "sap/base/Log"
-    /*Be careful by adding dependencies: Module is used in uhsell's boottask! */
-], function (Log) {
+    /* Be careful by adding dependencies: Module is used in uhsell's boottask! */
+], (Log) => {
     "use strict";
 
-
-    var _oHub = {
-        pendingEvents: { /* sEventName -> vData */ },
-        subscribers: { /* sEventName -> fnCallback */ },
-        dispatchOperations: { /* sEventName -> oDispatchOperation */ },
-        store: createEmptyStore()
-    };
-
     function createEmptyStore () {
         return {
             nextKey: 0,
@@ -27,23 +19,30 @@ sap.ui.define([
         };
     }
 
+    const _oHub = {
+        pendingEvents: { /* sEventName -> vData */ },
+        subscribers: { /* sEventName -> fnCallback */ },
+        dispatchOperations: { /* sEventName -> oDispatchOperation */ },
+        store: createEmptyStore()
+    };
+
     function log (sMessage, sDetails, fnCausedBy) {
         Log.error(sMessage, sDetails, "sap.ushell.EventHub");
         return;
     }
 
     function logCallbackError (oError) {
-        var sMessage = "An exception was raised while executing a registered callback on event '" + oError.eventName + "'",
-            sDetails = "Data passed to the event were: '" + oError.eventData + "'";
+        const sMessage = `An exception was raised while executing a registered callback on event '${oError.eventName}'`;
+        let sDetails = `Data passed to the event were: '${oError.eventData}'`;
         if (oError.error.stack) {
-            sDetails += " Error details: " + oError.error.stack;
+            sDetails += ` Error details: ${oError.error.stack}`;
         }
 
         log(sMessage, sDetails, oError.fnCausedBy);
     }
 
     function safeCall (sEvent, fnCallback, vData) {
-        var vResult;
+        let vResult;
         try {
             vResult = fnCallback(vData);
         } catch (oError) {
@@ -58,14 +57,31 @@ sap.ui.define([
         return vResult;
     }
 
-    function JSONReplacer (oHub /*sKey, vPropertyValue*/) {
+    function storeSave (oHub, vObject) {
+        if (oHub.store.objectToKey.has(vObject)) {
+            return oHub.store.objectToKey.get(vObject);
+        }
+
+        oHub.store.nextKey++;
+        const sKey = `<${typeof vObject}>#${oHub.store.nextKey}`;
+        oHub.store.keyToObject[sKey] = vObject;
+        oHub.store.objectToKey.set(vObject, sKey);
+
+        return sKey;
+    }
+
+    function JSONReplacer (oHub /* sKey, vPropertyValue */) {
         if (typeof arguments[2] === "function") {
             return storeSave(oHub, arguments[2]);
         }
         return arguments[2];
     }
 
-    function JSONReviver (oHub /*sKey, vPropertyValue*/) {
+    function storeLoad (oHub, sKey) {
+        return oHub.store.keyToObject[sKey];
+    }
+
+    function JSONReviver (oHub /* sKey, vPropertyValue */) {
         if (typeof arguments[2] === "string" && arguments[2].indexOf("<function") === 0) {
             return storeLoad(oHub, arguments[2]);
         }
@@ -75,13 +91,13 @@ sap.ui.define([
     function serialize (oHub, vData, /* optional */ bPretty) {
         if (typeof vData === "object" || typeof vData === "function") {
             try {
-                var aStringifyArgs = [vData, JSONReplacer.bind(null, oHub)];
+                const aStringifyArgs = [vData, JSONReplacer.bind(null, oHub)];
                 if (bPretty) {
                     aStringifyArgs.push(3);
                 }
                 return JSON.stringify.apply(JSON, aStringifyArgs);
             } catch (oError) {
-                log("" + oError, oError.stack, serialize);
+                log(`${oError}`, oError.stack, serialize);
             }
         }
         return vData;
@@ -95,7 +111,7 @@ sap.ui.define([
         }
     }
 
-    /**
+    /*
      * Subscribe a group of subscribers.
      */
     function subscribe (oHub, sEvent, aSubscriberGroup) {
@@ -105,67 +121,69 @@ sap.ui.define([
         oHub.subscribers[sEvent].push(aSubscriberGroup);
     }
 
-    /**
+    /*
      * Find and unsubscribe a subscriber from the hub using its event handler for searching.
      */
     function unsubscribe (oHub, sEvent, fnHandler) {
         oHub.subscribers[sEvent] = (oHub.subscribers[sEvent] || [])
-            .map(function (aSubscriberGroup) {
-                return aSubscriberGroup.filter(function (oListener) {
+            .map((aSubscriberGroup) => {
+                return aSubscriberGroup.filter((oListener) => {
                     return oListener.fn !== fnHandler;
                 });
             })
-            .filter(function (aGroup) {
+            .filter((aGroup) => {
                 return aGroup.length > 0;
             });
     }
 
     function createDispatchOperation () {
-        var fnDispatchComplete,
-            oDispatchPromise = new Promise(function (fnResolve) {
-                fnDispatchComplete = fnResolve;
-            }),
-            oDispatchOperation = {
-                dispatching: oDispatchPromise,
-                cancelled: false,
-                cancel: function () {
-                    oDispatchOperation.cancelled = true;
-                },
-                complete: function () {
-                    fnDispatchComplete();
-                }
-            };
+        let fnDispatchComplete;
+        const oDispatchPromise = new Promise((fnResolve) => {
+            fnDispatchComplete = fnResolve;
+        });
+        const oDispatchOperation = {
+            dispatching: oDispatchPromise,
+            cancelled: false,
+            cancel: function () {
+                oDispatchOperation.cancelled = true;
+            },
+            complete: function () {
+                fnDispatchComplete();
+            }
+        };
 
         return oDispatchOperation;
     }
 
-    function dispatchEvent (oHub, sEvent) {
-        if (!oHub.subscribers.hasOwnProperty(sEvent)) {
-            return null; // no interested parties
-        }
+    function notifySubscriber (oHub, sEvent, oSubscriber, aSubscriberGroup) {
+        const vDeserializedValue = deserialize(oHub, oHub.pendingEvents[sEvent]);
+        return Promise.resolve().then(() => {
+            if (oSubscriber.called && aSubscriberGroup.offed) {
+                return false;
+            }
+            oSubscriber.called = true;
 
-        var oDispatchOperation = createDispatchOperation(),
-            // -- dispatch
-            aSubscriberGroups = oHub.subscribers[sEvent],
-            aGroupsDispatchedPromise = aSubscriberGroups.map(function (aSubscriberGroup) {
-                return dispatchEventToGroup(oHub, sEvent, aSubscriberGroup, oDispatchOperation, 0);
-            });
+            // check handler was offed as late as possible to allow off before the call
+            const bOffBeforeCall = aSubscriberGroup.offed;
+            safeCall(sEvent, oSubscriber.fn, vDeserializedValue);
+            const bOffAfterCall = aSubscriberGroup.offed;
 
-        Promise.all(aGroupsDispatchedPromise).then(
-            oDispatchOperation.complete,
-            oDispatchOperation.complete
-        );
+            // -- unsubscribe offed subscriber after the call as it was already called and offed
+            if (bOffAfterCall) {
+                unsubscribe(oHub, sEvent, oSubscriber.fn);
+            }
 
-        return oDispatchOperation;
+            return !bOffBeforeCall && bOffAfterCall;
+        });
     }
 
     function dispatchEventToGroup (oHub, sEvent, aSubscriberGroup, oDispatchOperation, iStartFrom) {
-        var iOriginalGroupSize = aSubscriberGroup.length,
-            aSubscriberGroupSlice = aSubscriberGroup.slice(iStartFrom);
+        const iOriginalGroupSize = aSubscriberGroup.length;
+        const aSubscriberGroupSlice = aSubscriberGroup.slice(iStartFrom);
 
         return aSubscriberGroupSlice.reduce(
-            function (oPreviousHandlerCalledPromise, oSubscriber) {
-                return oPreviousHandlerCalledPromise.then(function (bOffCalledFromHandler) {
+            (oPreviousHandlerCalledPromise, oSubscriber) => {
+                return oPreviousHandlerCalledPromise.then((bOffCalledFromHandler) => {
                     if (oDispatchOperation.cancelled) {
                         if (bOffCalledFromHandler) {
                             unsubscribe(oHub, sEvent, oSubscriber.fn); // don't notify next listener in the group
@@ -173,7 +191,7 @@ sap.ui.define([
                         return bOffCalledFromHandler;
                     }
                     return notifySubscriber(oHub, sEvent, oSubscriber, aSubscriberGroup)
-                        .then(function (bSubscriberCallbackCalledOff) {
+                        .then((bSubscriberCallbackCalledOff) => {
                             // -- off call detected
                             if (bSubscriberCallbackCalledOff) {
                                 oDispatchOperation.cancelled = true;
@@ -183,7 +201,7 @@ sap.ui.define([
                 });
             },
             Promise.resolve(false /* Off called from handler */)
-        ).then(function (bHandlerCalledOff) {
+        ).then((bHandlerCalledOff) => {
             // if listeners called do inside a do, the group size increases
             if (!bHandlerCalledOff && iOriginalGroupSize < aSubscriberGroup.length) {
                 // dispatch to remaining
@@ -193,32 +211,30 @@ sap.ui.define([
         });
     }
 
-    function notifySubscriber (oHub, sEvent, oSubscriber, aSubscriberGroup) {
-        var vDeserializedValue = deserialize(oHub, oHub.pendingEvents[sEvent]);
-        return Promise.resolve().then(function () {
-            if (oSubscriber.called && aSubscriberGroup.offed) {
-                return false;
-            }
-            oSubscriber.called = true;
+    function dispatchEvent (oHub, sEvent) {
+        if (!oHub.subscribers.hasOwnProperty(sEvent)) {
+            return null; // no interested parties
+        }
 
-            // check handler was offed as late as possible to allow off before the call
-            var bOffBeforeCall = aSubscriberGroup.offed;
-            safeCall(sEvent, oSubscriber.fn, vDeserializedValue);
-            var bOffAfterCall = aSubscriberGroup.offed;
+        const oDispatchOperation = createDispatchOperation();
+        // -- dispatch
+        const aSubscriberGroups = oHub.subscribers[sEvent];
+        const aGroupsDispatchedPromise = aSubscriberGroups.map((aSubscriberGroup) => {
+            return dispatchEventToGroup(oHub, sEvent, aSubscriberGroup, oDispatchOperation, 0);
+        });
 
-            // -- unsubscribe offed subscriber after the call as it was already called and offed
-            if (bOffAfterCall) {
-                unsubscribe(oHub, sEvent, oSubscriber.fn);
-            }
+        Promise.all(aGroupsDispatchedPromise).then(
+            oDispatchOperation.complete,
+            oDispatchOperation.complete
+        );
 
-            return !bOffBeforeCall && bOffAfterCall;
-        });
+        return oDispatchOperation;
     }
 
     function createFnOff (oHub, sEvent, aSubscriberGroup) {
         // When off is called, it immediately removes any subscribed listener that was already called.
         return function () {
-            aSubscriberGroup.forEach(function (oListener) {
+            aSubscriberGroup.forEach((oListener) => {
                 unsubscribe(oHub, sEvent, oListener.fn);
             });
 
@@ -232,7 +248,7 @@ sap.ui.define([
     function createFnDo (oHub, sEvent, aSubscriberGroup) {
         // Create a new subscriber and add it to the given subscriber group.
         return function (fnCallback) {
-            var oSubscriber = {
+            const oSubscriber = {
                 fn: fnCallback,
                 called: false
             };
@@ -242,7 +258,7 @@ sap.ui.define([
 
             if (oHub.pendingEvents.hasOwnProperty(sEvent)) {
                 // check if event is being dispatched already
-                var oDispatchOperation = oHub.dispatchOperations[sEvent];
+                const oDispatchOperation = oHub.dispatchOperations[sEvent];
                 if (!oDispatchOperation) {
                     notifySubscriber(oHub, sEvent, oSubscriber, aSubscriberGroup);
                 } else {
@@ -262,7 +278,7 @@ sap.ui.define([
                      * Expectation is that sequence is kept during dispatching.
                      * So we wait on the ongoing dispatching operation and continue afterwards.
                      */
-                    oDispatchOperation.dispatching.then(function () {
+                    oDispatchOperation.dispatching.then(() => {
                         if (!oSubscriber.called) {
                             notifySubscriber(oHub, sEvent, oSubscriber, aSubscriberGroup);
                         }
@@ -288,10 +304,12 @@ sap.ui.define([
      * - "off": indicates that #off was called on behalf of the whole group.
      *   Indicating that if a handler was already called it shouldn't be called ever again.
      *
+     * @param {object} oHub the hub.
+     * @param {string} sEvent the event name.
      * @returns {object} a Doable
      */
     function on (oHub, sEvent) {
-        var aSubscriberGroup = [];
+        const aSubscriberGroup = [];
         subscribe(oHub, sEvent, aSubscriberGroup);
 
         return {
@@ -301,7 +319,7 @@ sap.ui.define([
     }
 
     function once (oHub, sEvent) {
-        var oDoable = on(oHub, sEvent);
+        const oDoable = on(oHub, sEvent);
         oDoable.off();
         return oDoable;
     }
@@ -310,25 +328,28 @@ sap.ui.define([
      * Emit an event - it really does only if data have changed.
      *
      * Event data are updated immediately.
-     * When new data enter, any pending dispatching is interrupted and a new (asyncronous) dispatching takes place.
+     * When new data enter, any pending dispatching is interrupted and a new (asynchronous) dispatching takes place.
+     * @param {object} oHub the hub.
+     * @param {string} sEvent the event name.
+     * @param {object} oData the event data.
+     * @param {boolean} bForce whether the notification is forced.
      * @returns {this} Reference to <code>this</code> for method chaining.
      */
     function emit (oHub, sEvent, oData, bForce) {
-        var sSerializedData = serialize(oHub, oData);
+        const sSerializedData = serialize(oHub, oData);
 
         if (!bForce && oHub.pendingEvents.hasOwnProperty(sEvent)
             && oHub.pendingEvents[sEvent] === sSerializedData) {
-
             return this; // same data -> no need to emit again
         }
         oHub.pendingEvents[sEvent] = sSerializedData;
 
-        var oDispatchOperation = oHub.dispatchOperations[sEvent];
+        const oDispatchOperation = oHub.dispatchOperations[sEvent];
         if (oDispatchOperation) {
             oDispatchOperation.cancel();
         }
 
-        var oNewDispatchOperation = dispatchEvent(oHub, sEvent);
+        const oNewDispatchOperation = dispatchEvent(oHub, sEvent);
         oHub.dispatchOperations[sEvent] = oNewDispatchOperation;
 
         return this;
@@ -338,74 +359,57 @@ sap.ui.define([
         return deserialize(oHub, oHub.pendingEvents[sEvent]);
     }
 
-    function join (/*oHub, args*/) {
-        var aArgDoables = Array.prototype.slice.call(arguments);
+    function join (/* oHub, args */) {
+        const aArgDoables = Array.prototype.slice.call(arguments);
         aArgDoables.shift(); // oHub
 
-        var iCount = 0,
-            aOneTimeCounts = new Array(aArgDoables.length)
-                .join(",")
-                .split(",")
-                .map(function () {
-                    return 1;
-                }),
-            aEventValues = [],
-            oDoable = {
-                do: function (fnCallback) {
-                    aArgDoables.forEach(function (oArgDoable, iIdx) {
-                        oArgDoable.do(function (iIdx, vValue) {
-                            aEventValues[iIdx] = vValue;
-
-                            iCount += aOneTimeCounts[iIdx];
-                            aOneTimeCounts[iIdx] = 0; // never add again
-
-                            if (iCount === aArgDoables.length) {
-                                fnCallback.apply(null, aEventValues);
-                            }
-                        }.bind(null, iIdx));
-                    });
+        let iCount = 0;
+        const aOneTimeCounts = new Array(aArgDoables.length)
+            .join(",")
+            .split(",")
+            .map(() => {
+                return 1;
+            });
+        const aEventValues = [];
+        const oDoable = {
+            do: function (fnCallback) {
+                aArgDoables.forEach((oArgDoable, iIdx) => {
+                    oArgDoable.do(((iIdx, vValue) => {
+                        aEventValues[iIdx] = vValue;
+
+                        iCount += aOneTimeCounts[iIdx];
+                        aOneTimeCounts[iIdx] = 0; // never add again
+
+                        if (iCount === aArgDoables.length) {
+                            fnCallback.apply(null, aEventValues);
+                        }
+                    }).bind(null, iIdx));
+                });
 
-                    return { off: oDoable.off }; // don't allow chaining
-                },
-                off: function () {
-                    var fnOff = aArgDoables.reduce(function (fnOff, oArgDoable) {
-                        return oArgDoable.off();
-                    }, function () { });
+                return { off: oDoable.off }; // don't allow chaining
+            },
+            off: function () {
+                const fnOff = aArgDoables.reduce((fnOff, oArgDoable) => {
+                    return oArgDoable.off();
+                }, () => { });
 
-                    return { off: fnOff };
-                }
-            };
+                return { off: fnOff };
+            }
+        };
 
         return oDoable; // allow to call do after join
     }
 
     function wait (oHub, sEvent) {
-        var oDispatchOperation = oHub.dispatchOperations[sEvent];
+        const oDispatchOperation = oHub.dispatchOperations[sEvent];
 
         return oDispatchOperation
             ? oDispatchOperation.dispatching
             : Promise.resolve();
     }
 
-    function storeSave (oHub, vObject) {
-        if (oHub.store.objectToKey.has(vObject)) {
-            return oHub.store.objectToKey.get(vObject);
-        }
-
-        oHub.store.nextKey++;
-        var sKey = "<" + typeof vObject + ">#" + oHub.store.nextKey;
-        oHub.store.keyToObject[sKey] = vObject;
-        oHub.store.objectToKey.set(vObject, sKey);
-
-        return sKey;
-    }
-
-    function storeLoad (oHub, sKey) {
-        return oHub.store.keyToObject[sKey];
-    }
-
     function createEventHub (oHub) {
-        var oEventHub = {};
+        const oEventHub = {};
 
         oEventHub.emit = emit.bind(oEventHub, oHub);
         oEventHub.on = on.bind(null, oHub);
@@ -426,34 +430,34 @@ sap.ui.define([
     }
 
     function createChannel (oContract) {
-        var oEventHubData = {
+        const oEventHubData = {
             pendingEvents: {},
             subscribers: {},
             dispatchOperations: {},
             store: createEmptyStore()
-        },
-            oEventHub = createEventHub(oEventHubData),
-            oContractClone = deserialize(oEventHubData, serialize(oEventHubData, oContract));
+        };
+        const oEventHub = createEventHub(oEventHubData);
+        const oContractClone = deserialize(oEventHubData, serialize(oEventHubData, oContract));
 
         function parsePath (sPath) {
-            var sSeparator = sPath.charAt(0);
+            const sSeparator = sPath.charAt(0);
             if (sSeparator.match(/[a-zA-Z0-9]/)) {
-                throw new Error("Invalid path separator '" + sSeparator + "'. Please ensure path starts with a non alphanumeric character");
+                throw new Error(`Invalid path separator '${sSeparator}'. Please ensure path starts with a non alphanumeric character`);
             }
 
-            var aPath = sPath.split(sSeparator);
+            const aPath = sPath.split(sSeparator);
             aPath.shift(); // initial separator character
             return aPath;
         }
 
         function serializePath (vPrefixOrPath, aMaybePath) {
-            var aPath = vPrefixOrPath,
-                sPrefix = "";
+            let aPath = vPrefixOrPath;
+            let sPrefix = "";
             if (arguments.length === 2) {
                 aPath = aMaybePath;
                 sPrefix = vPrefixOrPath;
             }
-            return sPrefix + "/" + aPath.join("/");
+            return `${sPrefix}/${aPath.join("/")}`;
         }
 
         function isArray (v) {
@@ -469,45 +473,45 @@ sap.ui.define([
         }
 
         function setObjectValue (oDef, vObject, aPath, vValue) {
-            var sPathSoFar = "",
-                oDefSoFar = oDef,
-                aPathsWritten = [];
+            let sPathSoFar = "";
+            let oDefSoFar = oDef;
+            const aPathsWritten = [];
 
-            aPath.reduce(function (oCurrentObject, sKey, iIdx) {
+            aPath.reduce((oCurrentObject, sKey, iIdx) => {
                 sPathSoFar = serializePath(sPathSoFar, [sKey]);
                 oDefSoFar = oDefSoFar[sKey];
 
                 if (iIdx === aPath.length - 1) {
                     if (!isPrimitive(vValue) && !isPrimitive(oDefSoFar) && Object.keys(oDefSoFar).length > 0) {
                         // Before writing, we need to check that the structure of the value we want to override allows it.
-                        var sExampleValue,
-                            oRemainingPaths = Object.keys(oDefSoFar).reduce(function (o, sKey) {
-                                o[sKey] = true;
-                                return o;
-                            }, {}),
-                            bKeysNotInContractOrNonEmpty = Object.keys(vValue).some(function (sKey) {
-                                sExampleValue = sKey;
-
-                                var bFoundInDef = oRemainingPaths.hasOwnProperty(sKey);
-                                delete oRemainingPaths[sKey];
-
-                                var bNonEmptyComplexType = !isPrimitive(oDefSoFar[sKey]) && Object.keys(oDefSoFar[sKey]).length > 0;
-
-                                return !bFoundInDef || bNonEmptyComplexType;
-                            }),
-                            bMissingKeys = (Object.keys(oRemainingPaths).length > 0),
-                            bIsOverrideForbidden = (bKeysNotInContractOrNonEmpty || bMissingKeys);
+                        let sExampleValue;
+                        const oRemainingPaths = Object.keys(oDefSoFar).reduce((o, sKey) => {
+                            o[sKey] = true;
+                            return o;
+                        }, {});
+                        const bKeysNotInContractOrNonEmpty = Object.keys(vValue).some((sKey) => {
+                            sExampleValue = sKey;
+
+                            const bFoundInDef = oRemainingPaths.hasOwnProperty(sKey);
+                            delete oRemainingPaths[sKey];
+
+                            const bNonEmptyComplexType = !isPrimitive(oDefSoFar[sKey]) && Object.keys(oDefSoFar[sKey]).length > 0;
+
+                            return !bFoundInDef || bNonEmptyComplexType;
+                        });
+                        const bMissingKeys = (Object.keys(oRemainingPaths).length > 0);
+                        const bIsOverrideForbidden = (bKeysNotInContractOrNonEmpty || bMissingKeys);
                         if (bIsOverrideForbidden) {
-                            var sReason = bKeysNotInContractOrNonEmpty
-                                ? "One or more values are not defined in the channel contract or are defined as a non-empty object/array, for example, check '" + sExampleValue + "'."
-                                : "Some keys are missing in the event data: " + Object.keys(oRemainingPaths).join(", ") + ".";
+                            const sReason = bKeysNotInContractOrNonEmpty
+                                ? `One or more values are not defined in the channel contract or are defined as a non-empty object/array, for example, check '${sExampleValue}'.`
+                                : `Some keys are missing in the event data: ${Object.keys(oRemainingPaths).join(", ")}.`;
 
-                            throw new Error("Cannot write value '" + serialize(oEventHubData, vValue, true /* bPretty */) + "' to path '" + sPathSoFar + "'. "
-                                + sReason
-                                + " All childrens in the value must appear in the channel contract and must have a simple value or should be defined as an empty complex value");
+                            throw new Error(`Cannot write value '${serialize(oEventHubData, vValue, true /* bPretty */)}' to path '${sPathSoFar}'. ${
+                                sReason
+                            } All childrens in the value must appear in the channel contract and must have a simple value or should be defined as an empty complex value`);
                         }
 
-                        var aAllPathsForValue = Object.keys(vValue).map(function (sKey) {
+                        const aAllPathsForValue = Object.keys(vValue).map((sKey) => {
                             return {
                                 serializedPath: serializePath(sPathSoFar, [sKey]),
                                 value: vValue[sKey]
@@ -536,26 +540,26 @@ sap.ui.define([
         }
 
         function getObjectValue (oObjectOrArray, aPath) {
-            var sPathSoFar = "",
-                oLastItem = aPath.reduce(function (oCurrentObject, sKey) {
-                    sPathSoFar += "/" + sKey;
+            let sPathSoFar = "";
+            const oLastItem = aPath.reduce((oCurrentObject, sKey) => {
+                sPathSoFar += `/${sKey}`;
 
-                    if (isArray(oCurrentObject) && !sKey.match(/^[0-9]+$/)) {
-                        throw new Error("Invalid array index '" + sKey + "' provided in path '" + sPathSoFar + "'");
-                    }
+                if (isArray(oCurrentObject) && !sKey.match(/^[0-9]+$/)) {
+                    throw new Error(`Invalid array index '${sKey}' provided in path '${sPathSoFar}'`);
+                }
 
-                    if (!oCurrentObject.hasOwnProperty(sKey)) {
-                        throw new Error("The item '" + sKey + "' from path " + sPathSoFar + " cannot be accessed in the object: " + serialize(oEventHubData, oCurrentObject));
-                    }
+                if (!oCurrentObject.hasOwnProperty(sKey)) {
+                    throw new Error(`The item '${sKey}' from path ${sPathSoFar} cannot be accessed in the object: ${serialize(oEventHubData, oCurrentObject)}`);
+                }
 
-                    return oCurrentObject[sKey];
-                }, oObjectOrArray);
+                return oCurrentObject[sKey];
+            }, oObjectOrArray);
             return oLastItem;
         }
 
         function getObjectValueOrDefault (oObjectOrArray, aPath, vDefault) {
-            return aPath.reduce(function (oCurrentObject, sKey, iIdx) {
-                var bLast = iIdx === (aPath.length - 1);
+            return aPath.reduce((oCurrentObject, sKey, iIdx) => {
+                const bLast = iIdx === (aPath.length - 1);
                 if (oCurrentObject.hasOwnProperty(sKey)) {
                     return oCurrentObject[sKey];
                 }
@@ -566,10 +570,10 @@ sap.ui.define([
         function getParentValues (oObject, aPath) {
             aPath.pop(); // we want to return only the *parent* paths.
 
-            var oValueSoFar = oObject,
-                aPathSoFar = [];
+            let oValueSoFar = oObject;
+            const aPathSoFar = [];
 
-            return aPath.reduce(function (aParentValues, sPathSegment) {
+            return aPath.reduce((aParentValues, sPathSegment) => {
                 oValueSoFar = oValueSoFar[sPathSegment];
                 aPathSoFar.push(sPathSegment);
                 aParentValues.push({
@@ -582,8 +586,8 @@ sap.ui.define([
 
         function findEmittableParentEvents (aAllWrittenValues) {
             return aAllWrittenValues
-                .map(function (oParentValue) {
-                    var sSerializedPath = oParentValue.serializedPath;
+                .map((oParentValue) => {
+                    const sSerializedPath = oParentValue.serializedPath;
 
                     if (!oEventHubData.subscribers.hasOwnProperty(sSerializedPath)
                         || oEventHubData.subscribers[sSerializedPath].length === 0) {
@@ -595,40 +599,40 @@ sap.ui.define([
                         value: oParentValue.value
                     };
                 })
-                .filter(function (oEvents) {
+                .filter((oEvents) => {
                     return !!oEvents;
                 });
         }
 
         function channelEmit (sPath, vData) {
-            var aPath = parsePath(sPath);
+            const aPath = parsePath(sPath);
 
             // check if path is valid
             getObjectValue(oContract, aPath); // throws if path is invalid
 
             // write in the clone
-            var aAllPathsAndValuesWritten = setObjectValue(oContract, oContractClone, aPath, vData);
+            const aAllPathsAndValuesWritten = setObjectValue(oContract, oContractClone, aPath, vData);
 
             // Emit in the channel for interested subscribers
-            aAllPathsAndValuesWritten.forEach(function (oParentEventInfo) {
+            aAllPathsAndValuesWritten.forEach((oParentEventInfo) => {
                 oEventHub.emit(oParentEventInfo.serializedPath, oParentEventInfo.value);
             });
         }
 
         function channelLast (sPath) {
-            var aPath = parsePath(sPath),
-                vValueFromOriginalObject = getObjectValue(oContract, aPath); // throws if path is invalid
+            const aPath = parsePath(sPath);
+            const vValueFromOriginalObject = getObjectValue(oContract, aPath); // throws if path is invalid
 
             return getObjectValueOrDefault(oContractClone, aPath, vValueFromOriginalObject);
         }
 
         function channelOn (sPath) {
             // publish event if we did not publish it before and there is a value in the object.
-            var aPath = parsePath(sPath),
-                sSerializedPath = serializePath(aPath),
-                // ensure on is called on an existing path
-                vLastChangedValue = oEventHub.last(sSerializedPath),
-                bValueWasChanged = oEventHubData.pendingEvents.hasOwnProperty(sSerializedPath);
+            const aPath = parsePath(sPath);
+            const sSerializedPath = serializePath(aPath);
+            // ensure on is called on an existing path
+            let vLastChangedValue = oEventHub.last(sSerializedPath);
+            const bValueWasChanged = oEventHubData.pendingEvents.hasOwnProperty(sSerializedPath);
             if (bValueWasChanged) {
                 return oEventHub.on(sSerializedPath);
             }
@@ -646,17 +650,17 @@ sap.ui.define([
         }
 
         function channelOnce (sPath) {
-            var oDoable = channelOn(sPath);
+            const oDoable = channelOn(sPath);
             oDoable.off();
             return oDoable;
         }
 
         function channelWait (sPath) {
-            var aPath = parsePath(sPath),
-                aParentValues = getParentValues(oContractClone, aPath),
-                aWaitPromises = findEmittableParentEvents(aParentValues).map(function (oParentEventInfo) {
-                    return oEventHub.wait(oParentEventInfo.path, oParentEventInfo.value);
-                });
+            const aPath = parsePath(sPath);
+            const aParentValues = getParentValues(oContractClone, aPath);
+            const aWaitPromises = findEmittableParentEvents(aParentValues).map((oParentEventInfo) => {
+                return oEventHub.wait(oParentEventInfo.path, oParentEventInfo.value);
+            });
             return Promise.all(aWaitPromises.concat(oEventHub.wait(sPath)));
         }
 
@@ -670,7 +674,7 @@ sap.ui.define([
         };
     }
 
-    var oExport = createEventHub(_oHub);
+    const oExport = createEventHub(_oHub);
     oExport.createChannel = createChannel.bind(null);
 
     return oExport;