@openui5/sap.ui.fl 1.128.0 → 1.130.0

package/src/sap/ui/fl/ChangePersistence.js

@@ -6,69 +6,41 @@
 
 sap.ui.define([
 	"sap/base/Log",
-	"sap/ui/core/util/reflection/JsControlTreeModifier",
-	"sap/ui/core/Component",
-	"sap/ui/fl/apply/_internal/changes/Applier",
-	"sap/ui/fl/apply/_internal/flexObjects/FlexObjectFactory",
 	"sap/ui/fl/apply/_internal/flexObjects/States",
 	"sap/ui/fl/apply/_internal/flexState/changes/DependencyHandler",
 	"sap/ui/fl/apply/_internal/flexState/changes/UIChangesState",
-	"sap/ui/fl/apply/_internal/flexState/controlVariants/VariantManagementState",
-	"sap/ui/fl/apply/_internal/flexState/DataSelector",
 	"sap/ui/fl/apply/_internal/flexState/FlexObjectState",
 	"sap/ui/fl/apply/_internal/flexState/FlexState",
 	"sap/ui/fl/initial/api/Version",
 	"sap/ui/fl/registry/Settings",
 	"sap/ui/fl/write/_internal/condenser/Condenser",
+	"sap/ui/fl/write/_internal/flexState/FlexObjectManager",
 	"sap/ui/fl/write/_internal/Storage",
 	"sap/ui/fl/Layer",
-	"sap/ui/fl/LayerUtils",
-	"sap/ui/fl/Utils"
+	"sap/ui/fl/LayerUtils"
 ], function(
 	Log,
-	JsControlTreeModifier,
-	Component,
-	Applier,
-	FlexObjectFactory,
 	States,
 	DependencyHandler,
 	UIChangesState,
-	VariantManagementState,
-	DataSelector,
 	FlexObjectState,
 	FlexState,
 	Version,
 	Settings,
 	Condenser,
+	FlexObjectManager,
 	Storage,
 	Layer,
-	LayerUtils,
-	Utils
+	LayerUtils
 ) {
 	"use strict";
 
-	const oVariantIndependentUIChangesDataSelector = new DataSelector({
-		id: "variantIndependentUIChanges",
-		parentDataSelector: FlexState.getFlexObjectsDataSelector(),
-		executeFunction(aFlexObjects) {
-			return aFlexObjects.filter(function(oFlexObject) {
-				const bIsUIChange = oFlexObject.isA("sap.ui.fl.apply._internal.flexObjects.UIChange");
-				const bIsControllerExtension = oFlexObject.isA("sap.ui.fl.apply._internal.flexObjects.ControllerExtensionChange");
-				const bCorrectFileType = oFlexObject.getFileType() === "change" || oFlexObject.getFileType() === "codeExt";
-				return (bIsUIChange || bIsControllerExtension)
-					&& bCorrectFileType
-					&& !oFlexObject.getVariantReference()
-					&& !oFlexObject.getSelector().persistencyKey;
-			});
-		}
-	});
-
 	/**
 	 * Helper object to access a change from the back end. Access helper object for each change (and variant) which was fetched from the back end
 	 *
 	 * @constructor
 	 * @author SAP SE
-	 * @version 1.128.0
+	 * @version 1.130.0
 	 * @since 1.25.0
 	 * @private
 	 * @param {object} mComponent - Component data to initiate <code>ChangePersistence</code> instance
@@ -83,186 +55,6 @@ sap.ui.define([
 		}
 
 		this._oMessagebundle = undefined;
-		oVariantIndependentUIChangesDataSelector.clearCachedResult({reference: this._mComponent.name});
-	};
-
-	async function getChangesFromFlexState(sReference, mPropertyBag, bInvalidateCache) {
-		try {
-			if (bInvalidateCache) {
-				await FlexState.update(mPropertyBag);
-			}
-
-			await FlexState.getStorageResponse(sReference);
-		} catch (oError) {
-			Log.warning("Problem during ChangePersistence.prototype.getChangesForComponent");
-		}
-	}
-
-	/**
-	 * Calls the back end asynchronously and fetches all changes for the component
-	 * New changes (dirty state) that are not yet saved to the back end won't be returned.
-	 * @param {object} [mPropertyBag] Contains additional data needed for reading changes
-	 * @param {object} [mPropertyBag.appDescriptor] Manifest that belongs to the current running component
-	 * @param {string} [mPropertyBag.siteId] ID of the site belonging to the current running component
-	 * @param {string} [mPropertyBag.currentLayer] Specifies a single layer for loading changes. If this parameter is set, the max layer filtering is not applied
-	 * @param {boolean} [mPropertyBag.ignoreMaxLayerParameter] Indicates that changes shall be loaded without layer filtering
-	 * @param {boolean} [mPropertyBag.includeCtrlVariants] - Indicates that control variant changes shall be included
-	 * @param {string} [mPropertyBag.cacheKey] Key to validate the cache entry stored on client side
-	 * @param {string} [mPropertyBag.version] Number of the version to retrieve changes for
-	 * @param {boolean} bInvalidateCache - should the cache be invalidated
-	 * @returns {Promise} Promise resolving with an array of changes
-	 * @public
-	 */
-	ChangePersistence.prototype.getChangesForComponent = async function(mPropertyBag, bInvalidateCache) {
-		mPropertyBag ||= {};
-		await getChangesFromFlexState(this._mComponent.name, mPropertyBag, bInvalidateCache);
-
-		const aAllChanges = FlexState.getFlexObjectsDataSelector().get({reference: this._mComponent.name});
-		if (!aAllChanges.length) {
-			return [];
-		}
-
-		// TODO: remove and use UIChangesState
-		let aRelevantUIChanges = oVariantIndependentUIChangesDataSelector.get({reference: this._mComponent.name});
-
-		if (!mPropertyBag.includeCtrlVariants) {
-			aRelevantUIChanges = aRelevantUIChanges.concat(
-				VariantManagementState.getInitialUIChanges({reference: this._mComponent.name})
-			);
-		} else {
-			aRelevantUIChanges = aRelevantUIChanges.concat(
-				VariantManagementState.getVariantDependentFlexObjects(this._mComponent.name)
-			);
-		}
-
-		if (mPropertyBag.currentLayer) {
-			aRelevantUIChanges = LayerUtils.filterChangeOrChangeDefinitionsByCurrentLayer(aRelevantUIChanges, mPropertyBag.currentLayer);
-		}
-		return aRelevantUIChanges;
-	};
-
-	/**
-	 * Adds a new change into dependency map positioned right after the referenced change and updates the change dependencies
-	 *
-	 * @param {sap.ui.core.Component} oAppComponent - Application component for the view
-	 * @param {sap.ui.fl.apply._internal.flexObjects.FlexObject} oChange - Change instance
-	 * @param {sap.ui.fl.apply._internal.flexObjects.FlexObject} [oReferenceChange] - Reference change. New change is positioned right after this one in the dependency map
-	 */
-	ChangePersistence.prototype.addChangeAndUpdateDependencies = function(oAppComponent, oChange, oReferenceChange) {
-		// the change status should always be initial when it gets added to the map / dependencies
-		// if the component gets recreated the status of the change might not be initial
-		oChange.setInitialApplyState();
-		if (oReferenceChange) {
-			DependencyHandler.insertChange(oChange, this.getDependencyMapForComponent(), oReferenceChange);
-		}
-		DependencyHandler.addChangeAndUpdateDependencies(oChange, oAppComponent, this.getDependencyMapForComponent());
-	};
-
-	ChangePersistence.prototype._addRunTimeCreatedChangeToDependencyMap = function(oAppComponent, oChange) {
-		DependencyHandler.addRuntimeChangeToMap(oChange, oAppComponent, this.getDependencyMapForComponent());
-	};
-
-	/**
-	 * Getter for the private aggregation containing sap.ui.fl.apply._internal.flexObjects.FlexObject objects mapped by their selector ids.
-	 * @return {Object<string,object>} mChanges mapping with changes sorted by their selector ids
-	 * @public
-	 */
-	ChangePersistence.prototype.getDependencyMapForComponent = function() {
-		return FlexObjectState.getLiveDependencyMap(this._mComponent.name);
-	};
-
-	function finalizeChangeCreation(oChange, oAppComponent) {
-		this._addRunTimeCreatedChangeToDependencyMap(oAppComponent, oChange);
-		this._addPropagationListener(oAppComponent);
-	}
-
-	/**
-	 * Adds a new change and returns the id of the new change.
-	 *
-	 * @param {object} vChange - The complete and finalized JSON object representation the file content of the change or a Change instance
-	 * @param {sap.ui.core.Component} oAppComponent - Application component instance
-	 * @returns {sap.ui.fl.apply._internal.flexObjects.FlexObject} the newly created change
-	 * @public
-	 */
-	ChangePersistence.prototype.addChange = function(vChange, oAppComponent) {
-		var oChange = this.addDirtyChange(vChange);
-		finalizeChangeCreation.call(this, oChange, oAppComponent);
-		return oChange;
-	};
-
-	/**
-	 * Adds new changes and returns the ids of the new changes.
-	 *
-	 * @param {object[]} aChanges - Array with complete and finalized JSON object representation the file content of the changes or Change instances
-	 * @param {sap.ui.core.Component} oAppComponent - Application component instance
-	 * @returns {sap.ui.fl.apply._internal.flexObjects.FlexObject[]} the newly created changes
-	 * @public
-	 */
-	ChangePersistence.prototype.addChanges = function(aChanges, oAppComponent) {
-		var aNewChanges = this.addDirtyChanges(aChanges);
-		aNewChanges.forEach(function(oChange) {
-			finalizeChangeCreation.call(this, oChange, oAppComponent);
-		}.bind(this));
-		return aNewChanges;
-	};
-
-	function createChange(vChange) {
-		return (
-			typeof vChange.isA === "function"
-			&& vChange.isA("sap.ui.fl.apply._internal.flexObjects.FlexObject")
-		)
-			? vChange
-			: FlexObjectFactory.createFromFileContent(vChange);
-	}
-
-	/**
-	 * Adds a new dirty change.
-	 *
-	 * @param {object} vChange - JSON object of change or change object
-	 * @returns {sap.ui.fl.apply._internal.flexObjects.FlexObject} The prepared change object
-	 * @public
-	 */
-	ChangePersistence.prototype.addDirtyChange = function(vChange) {
-		const oNewChange = createChange(vChange);
-		FlexState.addDirtyFlexObject(this._mComponent.name, oNewChange);
-		return oNewChange;
-	};
-
-	/**
-	 * Adds new dirty changes.
-	 *
-	 * @param {object[]} aChanges - JSON objects of changes or change objects
-	 * @returns {sap.ui.fl.apply._internal.flexObjects.FlexObject[]} The prepared change objects
-	 * @public
-	 */
-	ChangePersistence.prototype.addDirtyChanges = function(aChanges) {
-		const aNewChanges = aChanges.map(createChange);
-		FlexState.addDirtyFlexObjects(this._mComponent.name, aNewChanges);
-		return aNewChanges;
-	};
-
-	/**
-	 * If the first changes were created, the <code>propagationListener</code> of <code>sap.ui.fl</code> might not yet
-	 * be attached to the application component and must be added then.
-	 *
-	 * @param {sap.ui.core.UIComponent} oComponent Component having an app component that might not have a propagation listener yet
-	 * @private
-	 */
-	ChangePersistence.prototype._addPropagationListener = function(oComponent) {
-		var oAppComponent = Utils.getAppComponentForControl(oComponent);
-		if (oAppComponent instanceof Component) {
-			var fnCheckIsNotFlPropagationListener = function(fnPropagationListener) {
-				return !fnPropagationListener._bIsSapUiFlFlexControllerApplyChangesOnControl;
-			};
-
-			var bNoFlPropagationListenerAttached = oAppComponent.getPropagationListeners().every(fnCheckIsNotFlPropagationListener);
-
-			if (bNoFlPropagationListenerAttached) {
-				var fnPropagationListener = Applier.applyAllChangesForControl.bind(Applier, oAppComponent, this._mComponent.name);
-				fnPropagationListener._bIsSapUiFlFlexControllerApplyChangesOnControl = true;
-				oAppComponent.addPropagationListener(fnPropagationListener);
-			}
-		}
 	};
 
 	ChangePersistence.prototype._deleteNotSavedChanges = function(aChanges, aCondensedChanges, bAlreadyDeletedViaCondense) {
@@ -276,7 +68,10 @@ sap.ui.define([
 				// Remove also from Cache if the persisted change is still there (e.g. navigate away and back to the app)
 				FlexState.updateStorageResponse(this._mComponent.name, [{flexObject: oChange.convertToFileContent(), type: "delete"}]);
 			} else {
-				this.deleteChange(oChange);
+				FlexObjectManager.deleteFlexObjects({
+					reference: this._mComponent.name,
+					flexObjects: [oChange]
+				});
 			}
 		}.bind(this));
 	};
@@ -316,13 +111,8 @@ sap.ui.define([
 		return bCondenserEnabled;
 	}
 
-	function isBackendCondensingEnabled(aChanges) {
-		var bEnabled = Settings.getInstanceOrUndef() && Settings.getInstanceOrUndef().isCondensingEnabled();
-		if (bEnabled && !checkIfOnlyOne(aChanges, "getNamespace")) {
-			bEnabled = false;
-		}
-
-		return bEnabled;
+	function isBackendCondensingEnabled() {
+		return Settings.getInstanceOrUndef()?.isCondensingEnabled();
 	}
 
 	function updateCacheAndDeleteUnsavedChanges(aAllChanges, aCondensedChanges, bSkipUpdateCache, bAlreadyDeletedViaCondense) {
@@ -360,19 +150,13 @@ sap.ui.define([
 	}
 
 	function executeWriteAndRemoveCalls(sCurrentLayer, sRequest, sParentVersion, bSkipUpdateCache, aAllChanges, aCondensedChanges) {
-		var aCondensedDeleteChanges = [];
-		var pRemoveCallsPromise = Promise.resolve();
-		var aNewChanges = aCondensedChanges.filter(function(oCondensedChange) {
-			if (oCondensedChange.getState() === States.LifecycleState.DELETED) {
-				aCondensedDeleteChanges.push(oCondensedChange);
-				return false;
-			}
-			return true;
-		});
+		let pRemoveCallsPromise = Promise.resolve();
+		const aDeletedChanges = aAllChanges.filter((oChange) => oChange.getState() === States.LifecycleState.DELETED);
+		const aNewChanges = aCondensedChanges.filter((oCondensedChange) => (oCondensedChange.getState() !== States.LifecycleState.DELETED));
 
 		// "remove" only supports a single change; multiple calls are required
-		if (aCondensedDeleteChanges.length) {
-			pRemoveCallsPromise = this.saveSequenceOfDirtyChanges(aCondensedDeleteChanges, bSkipUpdateCache, sParentVersion);
+		if (aDeletedChanges.length) {
+			pRemoveCallsPromise = this.saveSequenceOfDirtyChanges(aDeletedChanges, bSkipUpdateCache, sParentVersion);
 		}
 
 		// "write" supports multiple changes at once
@@ -421,52 +205,50 @@ sap.ui.define([
 		bCondenseAnyLayer,
 		sLayer
 	) {
-		var aDirtyChanges = aChanges || FlexObjectState.getDirtyFlexObjects(this._mComponent.name);
-		var sCurrentLayer = aDirtyChanges.length && aDirtyChanges[0].getLayer() || sLayer;
-		var aRelevantChangesForCondensing = getAllRelevantChangesForCondensing.call(
+		const aDirtyChanges = aChanges || FlexObjectState.getDirtyFlexObjects(this._mComponent.name);
+		const sCurrentLayer = aDirtyChanges.length && aDirtyChanges[0].getLayer() || sLayer;
+		const aRelevantChangesForCondensing = getAllRelevantChangesForCondensing.call(
 			this,
 			aDirtyChanges,
 			aDraftFilenames,
 			bCondenseAnyLayer,
 			sCurrentLayer
 		);
-		var bIsCondensingEnabled = (
-			isBackendCondensingEnabled(aRelevantChangesForCondensing)
+		const bIsCondensingEnabled = (
+			isBackendCondensingEnabled()
 			&& canGivenChangesBeCondensed(oAppComponent, aRelevantChangesForCondensing, bCondenseAnyLayer)
 		);
-		var aAllChanges = bIsCondensingEnabled ? aRelevantChangesForCondensing : aDirtyChanges;
-		var aChangesClone = aAllChanges.slice(0);
-		var aRequests = getRequests(aDirtyChanges);
+		const aAllFlexObjects = bIsCondensingEnabled ? aRelevantChangesForCondensing : aDirtyChanges;
+		const aChangesClone = aAllFlexObjects.slice(0);
+		const aRequests = getRequests(aDirtyChanges);
 
 		// Condensing is only allowed if all dirty changes belong to the same Transport Request
 		if (checkLayerAndSingleTransportRequest(aDirtyChanges)) {
-			var oCondensedChangesPromise = Promise.resolve(aChangesClone);
-			if (canGivenChangesBeCondensed(oAppComponent, aChangesClone, bCondenseAnyLayer)) {
-				oCondensedChangesPromise = Condenser.condense(oAppComponent, aChangesClone);
-			}
+			const oCondensedChangesPromise = canGivenChangesBeCondensed(oAppComponent, aChangesClone, bCondenseAnyLayer)
+				? Condenser.condense(oAppComponent, aChangesClone)
+				: Promise.resolve(aChangesClone);
 			return oCondensedChangesPromise.then(function(aCondensedChanges) {
-				var sRequest = aRequests[0];
+				const sRequest = aRequests[0];
 				if (bIsCondensingEnabled) {
 					return Storage.condense({
-						allChanges: aAllChanges,
+						allChanges: aAllFlexObjects,
 						condensedChanges: aCondensedChanges,
 						layer: sCurrentLayer,
 						transport: sRequest,
 						isLegacyVariant: false,
 						parentVersion: sParentVersion
 					}).then(function(oResponse) {
-						updateCacheAndDeleteUnsavedChanges.call(this, aAllChanges, aCondensedChanges, bSkipUpdateCache, true);
+						updateCacheAndDeleteUnsavedChanges.call(this, aAllFlexObjects, aCondensedChanges, bSkipUpdateCache, true);
 						return oResponse;
 					}.bind(this));
 				}
-				// Non-condensing route
 				return executeWriteAndRemoveCalls.call(
 					this,
 					sCurrentLayer,
 					sRequest,
 					sParentVersion,
 					bSkipUpdateCache,
-					aAllChanges,
+					aAllFlexObjects,
 					aCondensedChanges
 				);
 			}.bind(this));
@@ -490,7 +272,7 @@ sap.ui.define([
 		var oFirstNewChange;
 		if (sParentVersion) {
 			// in case of changes saved for a draft only the first writing operation must have the parentVersion targeting the basis
-			// followup changes must point the the existing draft created with the first request
+			// followup changes must point the existing draft created with the first request
 			var aNewChanges = aDirtyChanges.filter(function(oChange) {
 				return oChange.getState() === States.LifecycleState.NEW;
 			});
@@ -510,6 +292,7 @@ sap.ui.define([
 				oCollectedResponse.response.push(...oResponse.response);
 			}
 		}
+		FlexState.getFlexObjectsDataSelector().checkUpdate({reference: this._mComponent.name});
 		return oCollectedResponse;
 	};
 
@@ -558,7 +341,7 @@ sap.ui.define([
 						flexObject: oDirtyChange.convertToFileContent()
 					}]);
 					break;
-				case States.LifecycleState.DIRTY:
+				case States.LifecycleState.UPDATED:
 					FlexState.updateStorageResponse(this._mComponent.name, [{
 						type: "update",
 						flexObject: oDirtyChange.convertToFileContent()
@@ -567,7 +350,6 @@ sap.ui.define([
 				default:
 			}
 			oDirtyChange.setState(States.LifecycleState.PERSISTED);
-			FlexState.getFlexObjectsDataSelector().checkUpdate({reference: this._mComponent.name});
 		}
 	};
 
@@ -580,6 +362,7 @@ sap.ui.define([
 		aDirtyChanges.forEach(function(oDirtyChange) {
 			this._updateCacheAndDirtyState(oDirtyChange, bSkipUpdateCache);
 		}, this);
+		FlexState.getFlexObjectsDataSelector().checkUpdate({reference: this._mComponent.name});
 	};
 
 	function getRequests(aDirtyChanges) {
@@ -618,57 +401,8 @@ sap.ui.define([
 		return aChanges;
 	}
 
-	/**
-	 * Prepares a change to be deleted with the next call to
-	 * @see {ChangePersistence#saveDirtyChanges};
-	 *
-	 * If the given change is already in the dirty changes and
-	 * has the 'NEW' state it will be removed, assuming,
-	 * it has just been created in the current session;
-	 *
-	 * Otherwise it will be marked for deletion.
-	 *
-	 * @param {sap.ui.fl.apply._internal.flexObjects.FlexObject} oChange the change to be deleted
-	 * @param {boolean} [bRunTimeCreatedChange] set if the change was created at runtime
-	 * @param {boolean} [bSkipRemoveFromFlexState] set if the change should not be removed from the FlexState
-	 */
-	ChangePersistence.prototype.deleteChange = function(oChange, bRunTimeCreatedChange, bSkipRemoveFromFlexState) {
-		const nIndexInDirtyChanges = FlexObjectState.getDirtyFlexObjects(this._mComponent.name).indexOf(oChange);
-
-		if (nIndexInDirtyChanges > -1) {
-			if (oChange.getState() === States.LifecycleState.DELETED) {
-				return;
-			}
-			if (!bSkipRemoveFromFlexState) {
-				FlexState.removeDirtyFlexObject(this._mComponent.name, oChange);
-			}
-			this._deleteChangeInMap(oChange, bRunTimeCreatedChange);
-			return;
-		}
-
-		oChange.markForDeletion();
-		this.addDirtyChange(oChange);
-		this._deleteChangeInMap(oChange, bRunTimeCreatedChange);
-	};
-
-	/**
-	 * Prepares multiple changes to be deleted with the next call to
-	 * @see {ChangePersistence#saveDirtyChanges};
-	 *
-	 * Removal from the FlexState happens in one go to trigger only one invalidation.
-	 *
-	 * @param {sap.ui.fl.apply._internal.flexObjects.FlexObject[]} aChanges the changes to be deleted
-	 * @param {boolean} [bRunTimeCreatedChanges] set if the change was created at runtime
-	 */
-	ChangePersistence.prototype.deleteChanges = function(aChanges, bRunTimeCreatedChanges) {
-		aChanges.forEach(function(oChange) {
-			this.deleteChange(oChange, bRunTimeCreatedChanges, true);
-		}.bind(this));
-		FlexState.removeDirtyFlexObjects(this._mComponent.name, aChanges);
-	};
-
 	ChangePersistence.prototype.removeChange = function(oChange) {
-		FlexState.removeDirtyFlexObject(this._mComponent.name, oChange);
+		FlexState.removeDirtyFlexObjects(this._mComponent.name, [oChange]);
 		this._deleteChangeInMap(oChange);
 	};
 
@@ -681,164 +415,10 @@ sap.ui.define([
 	 */
 	ChangePersistence.prototype._deleteChangeInMap = function(oChange, bRunTimeCreatedChange) {
 		var sChangeKey = oChange.getId();
-		DependencyHandler.removeChangeFromMap(this.getDependencyMapForComponent(), sChangeKey);
+		DependencyHandler.removeChangeFromMap(FlexObjectState.getLiveDependencyMap(this._mComponent.name), sChangeKey);
 		if (!bRunTimeCreatedChange) {
-			DependencyHandler.removeChangeFromDependencies(this.getDependencyMapForComponent(), sChangeKey);
-		}
-	};
-
-	function isLocalAndInLayer(sLayer, oObject) {
-		return (oObject.getRequest() === "$TMP" || oObject.getRequest() === "") && oObject.getLayer() === sLayer;
-	}
-
-	function isPersistedAndInLayer(sLayer, oObject) {
-		return oObject.getState() === States.LifecycleState.PERSISTED && oObject.getLayer() === sLayer;
-	}
-
-	function getAllCompVariantsEntities() {
-		var aCompVariantEntities = [];
-		var mCompVariantsMap = FlexState.getCompVariantsMap(this._mComponent.name);
-		for (var sPersistencyKey in mCompVariantsMap) {
-			for (var sId in mCompVariantsMap[sPersistencyKey].byId) {
-				aCompVariantEntities.push(mCompVariantsMap[sPersistencyKey].byId[sId]);
-			}
-		}
-		return aCompVariantEntities;
-	}
-	/**
-	 * Transports all the UI changes and app variant descriptor (if exists) to the target system
-	 *
-	 * @param {object} oRootControl - the root control of the running application
-	 * @param {string} sStyleClass - RTA style class name
-	 * @param {string} sLayer - Working layer
-	 * @param {array} [aAppVariantDescriptors] - an array of app variant descriptors which needs to be transported
-	 * @returns {Promise} promise that resolves when all the artifacts are successfully transported
-	 */
-	ChangePersistence.prototype.transportAllUIChanges = function(oRootControl, sStyleClass, sLayer, aAppVariantDescriptors) {
-		return this.getChangesForComponent({currentLayer: sLayer, includeCtrlVariants: true}).then(function(aLocalChanges) {
-			var aCompVariantEntities = getAllCompVariantsEntities.call(this);
-
-			aLocalChanges = aLocalChanges.concat(
-				aCompVariantEntities.filter(isLocalAndInLayer.bind(this, sLayer)));
-
-			return Storage.publish({
-				transportDialogSettings: {
-					styleClass: sStyleClass
-				},
-				layer: sLayer,
-				reference: this._mComponent.name,
-				localChanges: aLocalChanges,
-				appVariantDescriptors: aAppVariantDescriptors
-			});
-		}.bind(this));
-	};
-
-	/**
-	 * Removes unsaved changes.
-	 *
-	 * @param {string|string[]} [vLayer] - Layer or multiple layers for which changes shall be deleted. If omitted, changes on all layers are considered.
-	 * @param {sap.ui.core.Component} [oComponent] - Component instance, required if oControl is specified
-	 * @param {string} [oControl] - Control for which the changes should be deleted. If omitted, all changes for the app component are considered.
-	 * @param {string} [sGenerator] - Generator of changes (optional)
-	 * @param {string[]} [aChangeTypes] - Types of changes (optional)
-	 *
-	 * @returns {Promise} Promise that resolves after the deletion took place
-	 */
-	ChangePersistence.prototype.removeDirtyChanges = function(vLayer, oComponent, oControl, sGenerator, aChangeTypes) {
-		var aLayers = [].concat(vLayer || []);
-		var aDirtyChanges = FlexObjectState.getDirtyFlexObjects(this._mComponent.name);
-
-		var aChangesToBeRemoved = aDirtyChanges.filter(function(oChange) {
-			var bChangeValid = true;
-
-			if (aLayers.length && !aLayers.includes(oChange.getLayer())) {
-				return false;
-			}
-
-			if (sGenerator && oChange.getSupportInformation().generator !== sGenerator) {
-				return false;
-			}
-
-			if (oControl) {
-				var vSelector = oChange.getSelector();
-				bChangeValid = oControl.getId() === JsControlTreeModifier.getControlIdBySelector(vSelector, oComponent);
-			}
-
-			if (aChangeTypes) {
-				bChangeValid &&= aChangeTypes.indexOf(oChange.getChangeType()) !== -1;
-			}
-
-			return bChangeValid;
-		});
-
-		FlexState.removeDirtyFlexObjects(this._mComponent.name, aChangesToBeRemoved);
-		aChangesToBeRemoved.forEach(function(oChange) {
-			var nIndex = aDirtyChanges.indexOf(oChange);
-			aDirtyChanges.splice(nIndex, 1);
-		});
-
-		return Promise.resolve(aChangesToBeRemoved);
-	};
-
-	/**
-	 * Reset changes on the server. Specification of a generator, selector string or change type string is optional
-	 * but at least one of these parameters has to be filled.
-	 * This function returns an array of changes which need to be reverted from UI. When neither a selector nor a change type is provided,
-	 * an empty array is returned (this triggers a reset of the changes for an entire application component and reloads it).
-	 *
-	 * @param {string} sLayer Layer for which changes shall be deleted
-	 * @param {string} [sGenerator] Generator of changes (optional)
-	 * @param {string[]} [aSelectorIds] Selector IDs in local format (optional)
-	 * @param {string[]} [aChangeTypes] Types of changes (optional)
-	 *
-	 * @returns {Promise} Promise that resolves with an array of changes which need to be reverted from UI
-	 */
-	ChangePersistence.prototype.resetChanges = async function(sLayer, sGenerator, aSelectorIds, aChangeTypes) {
-		const bSelectorIdsProvided = aSelectorIds && aSelectorIds.length > 0;
-		const bChangeTypesProvided = aChangeTypes && aChangeTypes.length > 0;
-
-		// In case of application reset and PUBLIC layer available, also includes comp variant entities
-		const isPublicLayerAvailable = Settings.getInstanceOrUndef() && Settings.getInstanceOrUndef().isPublicLayerAvailable();
-		const isApplicationReset = sGenerator === undefined && aSelectorIds === undefined && aChangeTypes === undefined;
-		const aCompVariantsEntries = (isPublicLayerAvailable && isApplicationReset) ?
-			getAllCompVariantsEntities.call(this).filter(isPersistedAndInLayer.bind(this, sLayer))
-			: [];
-
-		const aUiChanges = await this.getChangesForComponent({currentLayer: sLayer, includeCtrlVariants: true});
-		const aFlexObjects = aUiChanges.concat(aCompVariantsEntries);
-		const mParams = {
-			reference: this._mComponent.name,
-			layer: sLayer,
-			changes: aFlexObjects
-		};
-		if (sGenerator) {
-			mParams.generator = sGenerator;
-		}
-		if (bSelectorIdsProvided) {
-			mParams.selectorIds = aSelectorIds;
-		}
-		if (bChangeTypesProvided) {
-			mParams.changeTypes = aChangeTypes;
-		}
-
-		const oResponse = await Storage.reset(mParams);
-		// If reset changes for control, returns an array of deleted changes for reverting
-		if (aSelectorIds || aChangeTypes) {
-			const aNames = [];
-			if (oResponse && oResponse.response && oResponse.response.length > 0) {
-				oResponse.response.forEach(function(oChangeContentId) {
-					aNames.push(oChangeContentId.fileName);
-				});
-			}
-			const aChangesToRevert = UIChangesState.getAllUIChanges(this._mComponent.name).filter(function(oChange) {
-				return aNames.indexOf(oChange.getId()) !== -1;
-			});
-			FlexState.updateStorageResponse(this._mComponent.name, aChangesToRevert.map((oFlexObject) => {
-				return {flexObject: oFlexObject.convertToFileContent(), type: "delete"};
-			}));
-			return aChangesToRevert;
+			DependencyHandler.removeChangeFromDependencies(FlexObjectState.getLiveDependencyMap(this._mComponent.name), sChangeKey);
 		}
-		return [];
 	};
 
 	return ChangePersistence;

package/src/sap/ui/fl/ChangePersistenceFactory.js

@@ -19,7 +19,7 @@ sap.ui.define([
 	 * @alias sap.ui.fl.ChangePersistenceFactory
 	 * @since 1.27.0
 	 * @author SAP SE
-	 * @version 1.128.0
+	 * @version 1.130.0
 	 * @private
 	 * @ui5-restricted sap.ui.fl
 	 */

package/src/sap/ui/fl/FakeLrepConnectorLocalStorage.js

@@ -20,7 +20,7 @@ function(
 	 * @namespace
 	 *
 	 * @author SAP SE
-	 * @version 1.128.0
+	 * @version 1.130.0
 	 *
 	 * @private
 	 * @since 1.48

package/src/sap/ui/fl/FakeLrepConnectorSessionStorage.js

@@ -20,7 +20,7 @@ function(
 	 * @namespace
 	 *
 	 * @author SAP SE
-	 * @version 1.128.0
+	 * @version 1.130.0
 	 *
 	 * @private
 	 * @since 1.58

package/src/sap/ui/fl/FakeLrepLocalStorage.js

@@ -17,7 +17,7 @@ sap.ui.define([
 	 * @namespace
 	 *
 	 * @author SAP SE
-	 * @version 1.128.0
+	 * @version 1.130.0
 	 *
 	 * @private
 	 * @since 1.48