@openui5/sap.ui.fl 1.129.0 → 1.130.1

package/src/sap/ui/fl/write/_internal/condenser/Condenser.js

@@ -5,43 +5,43 @@
  */
 
 sap.ui.define([
+	"sap/base/util/restricted/_isEqual",
 	"sap/base/util/each",
 	"sap/base/util/isPlainObject",
 	"sap/base/util/ObjectPath",
 	"sap/base/Log",
 	"sap/ui/core/util/reflection/JsControlTreeModifier",
 	"sap/ui/core/Element",
-	"sap/ui/fl/changeHandler/condenser/Classification",
 	"sap/ui/fl/apply/_internal/changes/Utils",
-	"sap/ui/fl/apply/_internal/flexObjects/UIChange",
 	"sap/ui/fl/apply/_internal/flexObjects/States",
+	"sap/ui/fl/apply/_internal/flexObjects/UIChange",
+	"sap/ui/fl/changeHandler/condenser/Classification",
 	"sap/ui/fl/write/_internal/condenser/classifications/LastOneWins",
 	"sap/ui/fl/write/_internal/condenser/classifications/Reverse",
 	"sap/ui/fl/write/_internal/condenser/classifications/Update",
 	"sap/ui/fl/write/_internal/condenser/UIReconstruction",
 	"sap/ui/fl/write/_internal/condenser/Utils",
 	"sap/ui/fl/Utils",
-	"sap/ui/performance/Measurement",
-	"sap/base/util/restricted/_isEqual"
+	"sap/ui/performance/Measurement"
 ], function(
+	_isEqual,
 	each,
 	isPlainObject,
 	ObjectPath,
 	Log,
 	JsControlTreeModifier,
 	Element,
-	CondenserClassification,
 	ChangesUtils,
-	UIChange,
 	States,
+	UIChange,
+	CondenserClassification,
 	LastOneWins,
 	Reverse,
 	Update,
 	UIReconstruction,
 	CondenserUtils,
 	FlUtils,
-	Measurement,
-	_isEqual
+	Measurement
 ) {
 	"use strict";
 
@@ -51,34 +51,35 @@ sap.ui.define([
 	 * @namespace
 	 * @alias sap.ui.fl.write._internal.condenser.Condenser
 	 * @author SAP SE
-	 * @version 1.129.0
+	 * @version 1.130.1
 	 */
-	var Condenser = {};
+	const Condenser = {};
 
-	var UNCLASSIFIED = "unclassified";
+	const UNCLASSIFIED = "unclassified";
 
 	/**
 	 * Classification of the non-index-related changes
 	 *
 	 * @type {{lastOneWins: addLastOneWinsChange, reverse: addReverseChange}}
 	 */
-	var NON_INDEX_RELEVANT = {
+	const NON_INDEX_RELEVANT = {
 		lastOneWins: LastOneWins,
 		reverse: Reverse,
 		update: Update
 	};
 
-	var PROPERTIES_WITH_SELECTORS = ["affectedControl", "sourceContainer", "targetContainer", "updateControl"];
+	const PROPERTIES_WITH_SELECTORS = ["affectedControl", "sourceContainer", "targetContainer", "updateControl"];
 
 	/**
-	 * Verify 'move' subtype has already been added to the data structure before 'create' subtype and they both belong to the same targetContainer
+	 * Verify 'move' subtype has already been added to the data structure before 'create' subtype
+	 * and they both belong to the same targetContainer
 	 *
 	 * @param {object} mSubtypes - Map of properties that holds key-value pairs. A key is a unique identifier. A value is an array object that contains changes
 	 * @param {object} oCondenserInfo - Condenser specific information that is delivered by the change handler
 	 * @returns {boolean} <code>true</code> if the 'move' subtype has been added to the data structure before 'create' subtype
 	 */
 	function isCreateAfterMoveSubtype(mSubtypes, oCondenserInfo) {
-		var aMoveSubType = mSubtypes[CondenserClassification.Move];
+		const aMoveSubType = mSubtypes[CondenserClassification.Move];
 		return oCondenserInfo.classification === CondenserClassification.Create
 			&& aMoveSubType
 			&& aMoveSubType[aMoveSubType.length - 1].targetContainer === oCondenserInfo.targetContainer;
@@ -115,12 +116,12 @@ sap.ui.define([
 	 * @param {sap.ui.fl.apply._internal.flexObjects.FlexObject} oChange - Change instance that will be added to the array
 	 * @returns {Promise} resolves when the change is added to the data structure
 	 */
-	function addIndexRelatedChange(mClassifications, mUIReconstructions, oCondenserInfo, oChange) {
+	async function addIndexRelatedChange(mClassifications, mUIReconstructions, oCondenserInfo, oChange) {
 		if (
 			!isMoveAfterDestroySubtype(mClassifications, oCondenserInfo)
 			&& !isCreateAfterDestroySubtype(mClassifications, oCondenserInfo)
 		) {
-			var sClassification = oCondenserInfo.classification;
+			const sClassification = oCondenserInfo.classification;
 			if (!mClassifications[sClassification]) {
 				oCondenserInfo.change = oChange;
 				oChange.condenserState = "select";
@@ -138,19 +139,19 @@ sap.ui.define([
 			|| isCreateAfterDestroySubtype(mClassifications, oCondenserInfo)
 		) {
 			if (mClassifications[CondenserClassification.Move]) {
-				mClassifications[CondenserClassification.Move].forEach(function(oCondenserInfo) {
+				mClassifications[CondenserClassification.Move].forEach((oCondenserInfo) => {
 					oCondenserInfo.change.condenserState = "delete";
 				});
 				delete mClassifications[CondenserClassification.Move];
 			}
 			if (mClassifications[CondenserClassification.Destroy]) {
-				mClassifications[CondenserClassification.Destroy].forEach(function(oCondenserInfo) {
+				mClassifications[CondenserClassification.Destroy].forEach((oCondenserInfo) => {
 					oCondenserInfo.change.condenserState = "delete";
 				});
 				delete mClassifications[CondenserClassification.Destroy];
 			}
 		}
-		return UIReconstruction.addChange(mUIReconstructions, oCondenserInfo);
+		await UIReconstruction.addChange(mUIReconstructions, oCondenserInfo);
 	}
 
 	/**
@@ -158,13 +159,11 @@ sap.ui.define([
 	 * @param {object} mClassifications - Map of properties that holds key-value pairs. A key is a unique identifier. A value is an array object that contains changes
 	 * @param {object} oCondenserInfo - Condenser specific information that is delivered by the change handler
 	 * @param {sap.ui.fl.apply._internal.flexObjects.FlexObject} oChange - Change instance that will be added to the array
-	 * @returns {Promise} returns when change is added to the map
 	 */
 	function addNonIndexRelatedChange(mClassifications, oCondenserInfo, oChange) {
 		mClassifications[oCondenserInfo.classification] ||= {};
-		var mProperties = mClassifications[oCondenserInfo.classification];
+		const mProperties = mClassifications[oCondenserInfo.classification];
 		NON_INDEX_RELEVANT[oCondenserInfo.classification].addToChangesMap(mProperties, oCondenserInfo, oChange);
-		return Promise.resolve();
 	}
 
 	/**
@@ -177,18 +176,18 @@ sap.ui.define([
 	 * @param {sap.ui.fl.apply._internal.flexObjects.FlexObject} oChange - Change instance that will be added to the array
 	 * @returns {Promise} returns when change is added to the data structures
 	 */
-	function addClassifiedChange(mTypes, mUIReconstructions, aIndexRelatedChanges, oCondenserInfo, oChange) {
+	async function addClassifiedChange(mTypes, mUIReconstructions, aIndexRelatedChanges, oCondenserInfo, oChange) {
 		mTypes[oCondenserInfo.type] ||= {};
-		var mClassifications = mTypes[oCondenserInfo.type];
+		const mClassifications = mTypes[oCondenserInfo.type];
 
 		if (oCondenserInfo.type === CondenserUtils.NOT_INDEX_RELEVANT) {
-			return addNonIndexRelatedChange(mClassifications, oCondenserInfo, oChange);
+			addNonIndexRelatedChange(mClassifications, oCondenserInfo, oChange);
+		} else {
+			aIndexRelatedChanges.push(oChange);
+			// with custom aggregations multiple aggregations can have the same affectedControl
+			mClassifications[oCondenserInfo.targetAggregation] ||= {};
+			await addIndexRelatedChange(mClassifications[oCondenserInfo.targetAggregation], mUIReconstructions, oCondenserInfo, oChange);
 		}
-
-		aIndexRelatedChanges.push(oChange);
-		// with custom aggregations multiple aggregations can have the same affectedControl
-		mClassifications[oCondenserInfo.targetAggregation] ||= {};
-		return addIndexRelatedChange(mClassifications[oCondenserInfo.targetAggregation], mUIReconstructions, oCondenserInfo, oChange);
 	}
 
 	/**
@@ -211,44 +210,36 @@ sap.ui.define([
 	 * @param {sap.ui.fl.apply._internal.flexObjects.FlexObject} oChange - Change instance
 	 * @returns {Promise.<object>} - Resolves with the condenser information or undefined
 	 */
-	function getCondenserInfoFromChangeHandler(oAppComponent, oChange) {
-		var sControlId = JsControlTreeModifier.getControlIdBySelector(oChange.getSelector(), oAppComponent);
-		var oControl = Element.getElementById(sControlId);
+	async function getCondenserInfoFromChangeHandler(oAppComponent, oChange) {
+		const sControlId = JsControlTreeModifier.getControlIdBySelector(oChange.getSelector(), oAppComponent);
+		const oControl = Element.getElementById(sControlId);
 		if (oControl) {
-			var mPropertyBag = {
+			const mPropertyBag = {
 				modifier: JsControlTreeModifier,
 				appComponent: oAppComponent,
 				view: FlUtils.getViewForControl(oControl)
 			};
-			var mControl = ChangesUtils.getControlIfTemplateAffected(oChange, oControl, mPropertyBag);
-			return Promise.resolve(ChangesUtils.getChangeHandler(oChange, mControl, mPropertyBag))
-			.then(function(oChangeHandler) {
-				if (oChangeHandler && typeof oChangeHandler.getCondenserInfo === "function") {
-					return oChangeHandler.getCondenserInfo(oChange, mPropertyBag);
-				}
-				return undefined;
-			})
-			.then(function(oCondenserInfo) {
-				// changes in templates get the binding holder as selector but have the original selector
-				// inside the template as dependent selector. As there might be multiple different controls in the template
-				// the selectors have to be changed back before the maps gets created
-				if (oCondenserInfo && mControl.bTemplateAffected) {
-					replaceTemplateSelector(oCondenserInfo, oChange);
+			const mControl = ChangesUtils.getControlIfTemplateAffected(oChange, oControl, mPropertyBag);
+			try {
+				const oChangeHandler = await ChangesUtils.getChangeHandler(oChange, mControl, mPropertyBag);
+				if (typeof oChangeHandler.getCondenserInfo === "function") {
+					const oCondenserInfo = await oChangeHandler.getCondenserInfo(oChange, mPropertyBag);
+					if (oCondenserInfo && mControl.bTemplateAffected) {
+						replaceTemplateSelector(oCondenserInfo, oChange);
+					}
+					return oCondenserInfo;
 				}
-				return oCondenserInfo;
-			})
-			.catch(function() {
+			} catch (oError) {
 				return undefined;
-			});
+			}
 		}
-
-		return Promise.resolve();
+		return undefined;
 	}
 
 	function replaceTemplateSelector(oCondenserInfo, oChange) {
-		var oOriginalSelector = oChange.getOriginalSelector();
-		var oTemplateSelector = oChange.getSelector();
-		PROPERTIES_WITH_SELECTORS.forEach(function(sPropertyName) {
+		const oOriginalSelector = oChange.getOriginalSelector();
+		const oTemplateSelector = oChange.getSelector();
+		PROPERTIES_WITH_SELECTORS.forEach((sPropertyName) => {
 			if (oCondenserInfo[sPropertyName] && oCondenserInfo[sPropertyName] === oTemplateSelector) {
 				oCondenserInfo[sPropertyName] = oOriginalSelector;
 			}
@@ -265,16 +256,16 @@ sap.ui.define([
 	 * @returns {object} Classification types map
 	 */
 	function getTypesMap(mReducedChanges, oCondenserInfo, oChange, oAppComponent) {
-		var sAffectedControlId = oCondenserInfo !== undefined
+		const sAffectedControlId = oCondenserInfo !== undefined
 			? oCondenserInfo.affectedControl
 			: JsControlTreeModifier.getControlIdBySelector(oChange.getSelector(), oAppComponent);
 		mReducedChanges[sAffectedControlId] ||= {};
 		// If an updateControl is present, it means that the update has a different selector from the other changes
 		// (e.g. iFrame added as Section) and the changes must be brought to the same group (= same affected control)
 		if (oCondenserInfo && oCondenserInfo.updateControl) {
-			var sUpdateControlId = oCondenserInfo.updateControl;
-			var aPath = [CondenserUtils.NOT_INDEX_RELEVANT, CondenserClassification.Update, oCondenserInfo.uniqueKey];
-			var oUpdateCondenserInfo = ObjectPath.get(aPath, mReducedChanges[sUpdateControlId]);
+			const sUpdateControlId = oCondenserInfo.updateControl;
+			const aPath = [CondenserUtils.NOT_INDEX_RELEVANT, CondenserClassification.Update, oCondenserInfo.uniqueKey];
+			const oUpdateCondenserInfo = ObjectPath.get(aPath, mReducedChanges[sUpdateControlId]);
 			if (oUpdateCondenserInfo) {
 				ObjectPath.set(aPath, oUpdateCondenserInfo, mReducedChanges[sAffectedControlId]);
 				delete mReducedChanges[sUpdateControlId][CondenserUtils.NOT_INDEX_RELEVANT]
@@ -331,29 +322,26 @@ sap.ui.define([
 	 * @param {sap.ui.fl.apply._internal.flexObjects.FlexObject[]} aChanges - All Change instances
 	 * @returns {Promise} Resolves when all changes were added to the maps
 	 */
-	function defineMaps(oAppComponent, mReducedChanges, mUIReconstructions, aIndexRelatedChanges, aChanges) {
-		return aChanges.reduce(function(oPromise, oChange) {
-			return oPromise.then(addChangeToMap.bind(this, oAppComponent, mReducedChanges, mUIReconstructions, aIndexRelatedChanges, oChange));
-		}.bind(this), Promise.resolve());
+	async function defineMaps(oAppComponent, mReducedChanges, mUIReconstructions, aIndexRelatedChanges, aChanges) {
+		for (const oChange of aChanges) {
+			await addChangeToMap(oAppComponent, mReducedChanges, mUIReconstructions, aIndexRelatedChanges, oChange);
+		}
 	}
 
-	function addChangeToMap(oAppComponent, mReducedChanges, mUIReconstructions, aIndexRelatedChanges, oChange) {
-		return getCondenserInfoFromChangeHandler(oAppComponent, oChange).then(function(oCondenserInfo) {
-			changeSelectorsToIdsInCondenserInfo(oCondenserInfo, oAppComponent);
-			var mTypes = getTypesMap(mReducedChanges, oCondenserInfo, oChange, oAppComponent);
-			if (oCondenserInfo !== undefined) {
-				addType(oCondenserInfo);
-				return addClassifiedChange(mTypes, mUIReconstructions, aIndexRelatedChanges, oCondenserInfo, oChange)
-				.then(function() {
-					if (oCondenserInfo.update) {
-						condenseUpdateChange(mTypes, oCondenserInfo, oChange);
-					}
-				});
+	async function addChangeToMap(oAppComponent, mReducedChanges, mUIReconstructions, aIndexRelatedChanges, oChange) {
+		const oCondenserInfo = await getCondenserInfoFromChangeHandler(oAppComponent, oChange);
+		changeSelectorsToIdsInCondenserInfo(oCondenserInfo, oAppComponent);
+		const mTypes = getTypesMap(mReducedChanges, oCondenserInfo, oChange, oAppComponent);
+		if (oCondenserInfo !== undefined) {
+			addType(oCondenserInfo);
+			await addClassifiedChange(mTypes, mUIReconstructions, aIndexRelatedChanges, oCondenserInfo, oChange);
+			if (oCondenserInfo.update) {
+				condenseUpdateChange(mTypes, oCondenserInfo, oChange);
 			}
+		} else {
 			addUnclassifiedChange(mTypes, UNCLASSIFIED, oChange);
 			mReducedChanges[UNCLASSIFIED] = true;
-			return undefined;
-		});
+		}
 	}
 
 	function addType(oCondenserInfo) {
@@ -365,7 +353,7 @@ sap.ui.define([
 	}
 
 	function changeSelectorsToIdsInCondenserInfo(oCondenserInfo, oAppComponent) {
-		PROPERTIES_WITH_SELECTORS.forEach(function(sPropertyName) {
+		PROPERTIES_WITH_SELECTORS.forEach((sPropertyName) => {
 			if (oCondenserInfo && oCondenserInfo[sPropertyName]) {
 				oCondenserInfo[sPropertyName] = JsControlTreeModifier.getControlIdBySelector(oCondenserInfo[sPropertyName], oAppComponent);
 			}
@@ -383,8 +371,8 @@ sap.ui.define([
 	 * @param {sap.ui.fl.apply._internal.flexObjects.FlexObject} oChange - The change that is getting updated
 	 */
 	function condenseUpdateChange(mTypes, oCondenserInfo, oChange) {
-		var aPath = [CondenserUtils.NOT_INDEX_RELEVANT, CondenserClassification.Update, oCondenserInfo.uniqueKey];
-		var oUpdateCondenserInfo = ObjectPath.get(aPath, mTypes);
+		const aPath = [CondenserUtils.NOT_INDEX_RELEVANT, CondenserClassification.Update, oCondenserInfo.uniqueKey];
+		const oUpdateCondenserInfo = ObjectPath.get(aPath, mTypes);
 		if (oUpdateCondenserInfo) {
 			oUpdateCondenserInfo.change.condenserState = "delete";
 			if (oChange.condenserState === "delete") {
@@ -407,15 +395,15 @@ sap.ui.define([
 	 * @returns {sap.ui.fl.apply._internal.flexObjects.FlexObject[]} All necessary changes in the map of reduced changes
 	 */
 	 function getChanges(mObjects, aChanges) {
-		each(mObjects, function(sKey, vSubObjects) {
+		each(mObjects, (sKey, vSubObjects) => {
 			if (NON_INDEX_RELEVANT[sKey] && NON_INDEX_RELEVANT[sKey].getChangesFromMap) {
-				NON_INDEX_RELEVANT[sKey].getChangesFromMap(mObjects, sKey).forEach(function(oChange) {
+				NON_INDEX_RELEVANT[sKey].getChangesFromMap(mObjects, sKey).forEach((oChange) => {
 					aChanges.push(oChange);
 				});
 			} else if (isPlainObject(vSubObjects)) {
 				return getChanges(vSubObjects, aChanges);
 			} else if (Array.isArray(vSubObjects)) {
-				vSubObjects.forEach(function(oObject) {
+				vSubObjects.forEach((oObject) => {
 					if (oObject instanceof UIChange) {
 						aChanges.push(oObject);
 					} else {
@@ -445,11 +433,11 @@ sap.ui.define([
 	 * @returns {object[]} Array of objects that contain condenser-specific information and change instance
 	 */
 	function getCondenserInfos(mReducedChanges, aCondenserInfos) {
-		each(mReducedChanges, function(sKey, vSubObjects) {
+		Object.values(mReducedChanges).forEach((vSubObjects) => {
 			if (isPlainObject(vSubObjects)) {
 				getCondenserInfos(vSubObjects, aCondenserInfos);
 			} else if (Array.isArray(vSubObjects)) {
-				vSubObjects.forEach(function(oObject) {
+				vSubObjects.forEach((oObject) => {
 					if (!(oObject instanceof UIChange)) {
 						aCondenserInfos.push(oObject);
 					}
@@ -466,23 +454,23 @@ sap.ui.define([
 	 * @param {sap.ui.fl.apply._internal.flexObjects.FlexObject[]} aReducedChanges - Array of reduced changes
 	 */
 	function sortByInitialOrder(aChanges, aReducedChanges) {
-		aReducedChanges.sort(function(a, b) {
+		aReducedChanges.sort((a, b) => {
 			return aChanges.indexOf(a) - aChanges.indexOf(b);
 		});
 	}
 
 	function sortCondenserInfosByInitialOrder(aChanges, aCondenserInfos) {
-		aCondenserInfos.sort(function(a, b) {
+		aCondenserInfos.sort((a, b) => {
 			return aChanges.indexOf(a.change) - aChanges.indexOf(b.change);
 		});
 	}
 
 	function addAllIndexRelatedChanges(aReducedChanges, aIndexRelatedChanges) {
-		var aReducedChangeIds = aReducedChanges.map(function(oChange) {
+		const aReducedChangeIds = aReducedChanges.map((oChange) => {
 			return oChange.getId();
 		});
 
-		aIndexRelatedChanges.forEach(function(oChange) {
+		aIndexRelatedChanges.forEach((oChange) => {
 			if (aReducedChangeIds.indexOf(oChange.getId()) === -1) {
 				aReducedChanges.push(oChange);
 			}
@@ -501,8 +489,8 @@ sap.ui.define([
 	 * @returns {sap.ui.fl.apply._internal.flexObjects.FlexObject[]} Updated reduced changes
 	 */
 	function handleChangeUpdate(aCondenserInfos, aReducedChanges, aReducedIndexRelatedChangesPerContainer) {
-		aCondenserInfos.forEach(function(oCondenserInfo) {
-			var oUpdateChange = oCondenserInfo.updateChange;
+		aCondenserInfos.forEach((oCondenserInfo) => {
+			const oUpdateChange = oCondenserInfo.updateChange;
 			if (
 				oUpdateChange
 				// "Update" only modifies the change content. If we support other
@@ -510,20 +498,20 @@ sap.ui.define([
 				&& !_isEqual(oUpdateChange.getContent(), oCondenserInfo.change.getContent())
 				&& oUpdateChange.getState() !== States.LifecycleState.NEW
 			) {
-				var oLastChange = oCondenserInfo.change;
+				const oLastChange = oCondenserInfo.change;
 				if (oUpdateChange.getId() !== oLastChange.getId()) {
-					var oNewContent = oLastChange.getContent();
+					const oNewContent = oLastChange.getContent();
 					oUpdateChange.setContent(oNewContent);
 					oUpdateChange.setRevertData(oLastChange.getRevertData());
 					oLastChange.condenserState = "delete";
-					aReducedChanges = aReducedChanges.map(function(oChange) {
+					aReducedChanges = aReducedChanges.map((oChange) => {
 						if (oChange.getId() === oLastChange.getId()) {
 							return oUpdateChange;
 						}
 						return oChange;
 					});
-					aReducedIndexRelatedChangesPerContainer.forEach(function(aReducedIndexRelatedChanges, iIndex) {
-						aReducedIndexRelatedChangesPerContainer[iIndex] = aReducedIndexRelatedChanges.map(function(oChange) {
+					aReducedIndexRelatedChangesPerContainer.forEach((aReducedIndexRelatedChanges, iIndex) => {
+						aReducedIndexRelatedChangesPerContainer[iIndex] = aReducedIndexRelatedChanges.map((oChange) => {
 							if (oChange.getId() === oLastChange.getId()) {
 								return oUpdateChange;
 							}
@@ -542,7 +530,8 @@ sap.ui.define([
 	/**
 	 * The condensing algorithm gets an array of changes that should be reduced to the bare minimum.
 	 * The steps of the algorithm are:
-	 * (1) Before starting the iteration process through the array of changes, the condenser reverses the array of changes to start the iteration backwards.
+	 * (1) Before starting the iteration process through the array of changes,
+	 * the condenser reverses the array of changes to start the iteration backwards.
 	 * By iterating through the array of changes, the condenser defines two data structures.
 	 * The first one contains reduced changes that are stored according to the classification per control.
 	 * The second one contains UI reconstructions of the corresponding UI parts.
@@ -558,21 +547,22 @@ sap.ui.define([
 	 * @param {sap.ui.fl.apply._internal.flexObjects.FlexObject[]} aChanges - Array of changes
 	 * @returns {Promise} Promise resolved with the reduced array of changes
 	 */
-	Condenser.condense = function(oAppComponent, aChanges) {
+	Condenser.condense = async function(oAppComponent, aChanges) {
 		Measurement.start("Condenser_overall", "Condenser overall - CondenserClass", ["sap.ui.fl", "Condenser"]);
-		var mReducedChanges = {};
-		var mUIReconstructions = {};
-		var aAllIndexRelatedChanges = [];
+		const mReducedChanges = {};
+		const mUIReconstructions = {};
+		const aAllIndexRelatedChanges = [];
 
 		// filter out objects which are not of type change, e.g. Variants, AppVariants, AppVariantInlineChange
 		// or are not applied (e.g. not part of the active variant) or were deleted
-		var aNotCondensableChanges = [];
-		var aCondensableChanges = [];
-		aChanges.slice(0).reverse().forEach(function(oChange) {
+		const aNotCondensableChanges = [];
+		const aCondensableChanges = [];
+		aChanges.slice(0).reverse().forEach((oChange) => {
+			if (oChange.getState() === States.LifecycleState.DELETED) {
+				oChange.condenserState = "delete";
+			}
 			if (oChange instanceof UIChange) {
-				if (oChange.getState() === States.LifecycleState.DELETED) {
-					oChange.condenserState = "delete";
-				} else if (oChange.isSuccessfullyApplied()) {
+				if (oChange.isSuccessfullyApplied()) {
 					aCondensableChanges.push(oChange);
 				} else {
 					aNotCondensableChanges.push(oChange);
@@ -583,80 +573,77 @@ sap.ui.define([
 		});
 
 		Measurement.start("Condenser_defineMaps", "defining of maps - CondenserClass", ["sap.ui.fl", "Condenser"]);
+		await defineMaps(oAppComponent, mReducedChanges, mUIReconstructions, aAllIndexRelatedChanges, aCondensableChanges);
+		Measurement.end("Condenser_defineMaps");
 
-		return defineMaps(oAppComponent, mReducedChanges, mUIReconstructions, aAllIndexRelatedChanges, aCondensableChanges)
+		const bUnclassifiedChanges = mReducedChanges[UNCLASSIFIED];
+		if (!bUnclassifiedChanges) {
+			UIReconstruction.compareAndUpdate(mReducedChanges, mUIReconstructions);
+		}
+		let aReducedChanges = getAllReducedChanges(mReducedChanges);
+
+		// with unclassified changes no index relevant changes can be reduced
+		if (bUnclassifiedChanges) {
+			aAllIndexRelatedChanges.forEach((oChange) => {
+				// If the index-relevant change is only being updated, this does not cause side effects
+				// If they are being removed (condenserState "delete"), they must be set to "select"
+				if (oChange.condenserState !== "update") {
+					oChange.condenserState = "select";
+				}
+			});
+			addAllIndexRelatedChanges(aReducedChanges, aAllIndexRelatedChanges);
+		}
 
-		.then(function() {
-			Measurement.end("Condenser_defineMaps");
-			var bUnclassifiedChanges = mReducedChanges[UNCLASSIFIED];
-			if (!bUnclassifiedChanges) {
-				UIReconstruction.compareAndUpdate(mReducedChanges, mUIReconstructions);
+		aReducedChanges = aReducedChanges.concat(aNotCondensableChanges);
+		sortByInitialOrder(aChanges, aReducedChanges);
+
+		if (!bUnclassifiedChanges) {
+			Measurement.start("Condenser_handleIndexRelatedChanges", "handle index related changes - CondenserClass", ["sap.ui.fl", "Condenser"]);
+
+			let bSuccess = true;
+			let aCondenserInfos = getCondenserInfos(mReducedChanges, []);
+			sortCondenserInfosByInitialOrder(aChanges, aCondenserInfos);
+			let aReducedIndexRelatedChangesPerContainer;
+			try {
+				Measurement.start("Condenser_sort", "sort index related changes - CondenserClass", ["sap.ui.fl", "Condenser"]);
+				aReducedIndexRelatedChangesPerContainer = UIReconstruction.sortIndexRelatedChanges(mUIReconstructions, aCondenserInfos);
+			} catch (oError) {
+				// an error here has to be treated similar to if there were some unclassified changes
+				// TODO: could be improved to only add all the changes of that specific container
+				Log.error(`Error during Condensing: ${oError.message}`, "No Condensing performed for index-relevant changes.");
+				bSuccess = false;
 			}
-			var aReducedChanges = getAllReducedChanges(mReducedChanges);
-
-			// with unclassified changes no index relevant changes can be reduced
-			if (bUnclassifiedChanges) {
-				aAllIndexRelatedChanges.forEach(function(oChange) {
-					// If the index-relevant change is only being updated, this does not cause side effects
-					// If they are being removed (condenserState "delete"), they must be set to "select"
-					if (oChange.condenserState !== "update") {
-						oChange.condenserState = "select";
-					}
+			Measurement.end("Condenser_sort");
+
+			if (bSuccess) {
+				// during the simulation more changes can become obsolete
+				aReducedChanges = aReducedChanges.filter((oChange) => {
+					return oChange.condenserState !== "delete";
+				});
+				aCondenserInfos = aCondenserInfos.filter((oCondenserInfo) => {
+					return oCondenserInfo.change.condenserState !== "delete";
+				});
+				// until now aReducedChanges still has the newer changes.
+				// after replacing them with the older change they have to be sorted again
+				aReducedChanges = handleChangeUpdate(aCondenserInfos, aReducedChanges, aReducedIndexRelatedChangesPerContainer);
+				sortByInitialOrder(aChanges, aReducedChanges);
+				// sort the different containers independently
+				aReducedIndexRelatedChangesPerContainer.forEach((aReducedIndexRelatedChanges) => {
+					UIReconstruction.swapChanges(aReducedIndexRelatedChanges, aReducedChanges);
+				});
+			} else {
+				aAllIndexRelatedChanges.forEach((oChange) => {
+					oChange.condenserState = "select";
 				});
 				addAllIndexRelatedChanges(aReducedChanges, aAllIndexRelatedChanges);
+				sortByInitialOrder(aChanges, aReducedChanges);
 			}
 
-			aReducedChanges = aReducedChanges.concat(aNotCondensableChanges);
-			sortByInitialOrder(aChanges, aReducedChanges);
-
-			if (!bUnclassifiedChanges) {
-				Measurement.start("Condenser_handleIndexRelatedChanges", "handle index related changes - CondenserClass", ["sap.ui.fl", "Condenser"]);
-
-				var bSuccess = true;
-				var aCondenserInfos = getCondenserInfos(mReducedChanges, []);
-				sortCondenserInfosByInitialOrder(aChanges, aCondenserInfos);
-				var aReducedIndexRelatedChangesPerContainer;
-				try {
-					Measurement.start("Condenser_sort", "sort index related changes - CondenserClass", ["sap.ui.fl", "Condenser"]);
-					aReducedIndexRelatedChangesPerContainer = UIReconstruction.sortIndexRelatedChanges(mUIReconstructions, aCondenserInfos);
-				} catch (oError) {
-					// an error here has to be treated similar to if there were some unclassified changes
-					// TODO: could be improved to only add all the changes of that specific container
-					Log.error(`Error during Condensing: ${oError.message}`, "No Condensing performed for index-relevant changes.");
-					bSuccess = false;
-				}
-				Measurement.end("Condenser_sort");
-
-				if (bSuccess) {
-					// during the simulation more changes can become obsolete
-					aReducedChanges = aReducedChanges.filter(function(oChange) {
-						return oChange.condenserState !== "delete";
-					});
-					aCondenserInfos = aCondenserInfos.filter(function(oCondenserInfo) {
-						return oCondenserInfo.change.condenserState !== "delete";
-					});
-					// until now aReducedChanges still has the newer changes.
-					// after replacing them with the older change they have to be sorted again
-					aReducedChanges = handleChangeUpdate(aCondenserInfos, aReducedChanges, aReducedIndexRelatedChangesPerContainer);
-					sortByInitialOrder(aChanges, aReducedChanges);
-					// sort the different containers independently
-					aReducedIndexRelatedChangesPerContainer.forEach(function(aReducedIndexRelatedChanges) {
-						UIReconstruction.swapChanges(aReducedIndexRelatedChanges, aReducedChanges);
-					});
-				} else {
-					aAllIndexRelatedChanges.forEach(function(oChange) {
-						oChange.condenserState = "select";
-					});
-					addAllIndexRelatedChanges(aReducedChanges, aAllIndexRelatedChanges);
-					sortByInitialOrder(aChanges, aReducedChanges);
-				}
-
-				Measurement.end("Condenser_handleIndexRelatedChanges");
-			}
+			Measurement.end("Condenser_handleIndexRelatedChanges");
+		}
 
-			Measurement.end("Condenser_overall");
-			return aReducedChanges;
-		});
+		Measurement.end("Condenser_overall");
+		return aReducedChanges;
 	};
 
 	return Condenser;