@openui5/sap.ui.fl 1.139.0 → 1.141.0

package/src/sap/ui/fl/apply/_internal/flexState/compVariants/CompVariantManagementState.js

@@ -5,13 +5,21 @@
  */
 
 sap.ui.define([
+	"sap/base/Log",
 	"sap/ui/fl/apply/_internal/flexState/FlexState",
 	"sap/ui/fl/apply/_internal/flexState/DataSelector",
-	"sap/ui/fl/apply/_internal/flexObjects/CompVariant"
+	"sap/ui/fl/apply/_internal/flexState/compVariants/applyChangesOnVariant",
+	"sap/ui/fl/apply/_internal/flexObjects/CompVariant",
+	"sap/ui/fl/apply/_internal/flexObjects/FlexObjectFactory",
+	"sap/ui/fl/apply/_internal/flexObjects/States"
 ], function(
+	Log,
 	FlexState,
 	DataSelector,
-	CompVariant
+	applyChangesOnVariant,
+	CompVariant,
+	FlexObjectFactory,
+	States
 ) {
 	"use strict";
 
@@ -20,7 +28,7 @@ sap.ui.define([
 	 *
 	 * @namespace sap.ui.fl.apply._internal.flexState.compVariants.CompVariantManagementState
 	 * @since 1.129
-	 * @version 1.139.0
+	 * @version 1.141.0
 	 * @private
 	 * @ui5-restricted
 	 */
@@ -28,6 +36,14 @@ sap.ui.define([
 
 	const sUpdatableChangeNameSpace = "sap.ui.fl.apply._internal.flexObjects.UpdatableChange";
 
+	const aCompVariantChangeTypes = [
+		"addFavorite",
+		"defaultVariant",
+		"removeFavorite",
+		"standardVariant",
+		"updateVariant"
+	];
+
 	const isSetDefaultChange = (oFlexObject) => {
 		return oFlexObject?.isA(sUpdatableChangeNameSpace)
 			&& oFlexObject.getFileType() === "change"
@@ -40,16 +56,166 @@ sap.ui.define([
 		parentDataSelector: FlexState.getFlexObjectsDataSelector(),
 		executeFunction(aFlexObjects, mPropertyBag) {
 			return aFlexObjects.filter((oFlexObject) =>
-				isSetDefaultChange(oFlexObject)
-				&& String(oFlexObject.getSelector()?.persistencyKey) === mPropertyBag.persistencyKey
+				(oFlexObject.getState() !== States.LifecycleState.DELETED || mPropertyBag.includeDeleted)
+				&& isSetDefaultChange(oFlexObject)
+				&& oFlexObject.getSelector().persistencyKey === mPropertyBag.persistencyKey
 			);
 		},
 		checkInvalidation(mParameters, oUpdateInfo) {
+			const oFlexObject = oUpdateInfo.updatedObject;
+			const bRelevantPersistencyKey = oFlexObject?.getSelector?.().persistencyKey === mParameters.persistencyKey;
 			const bRelevantType = ["addFlexObject", "removeFlexObject"].includes(oUpdateInfo.type);
-			return bRelevantType && isSetDefaultChange(oUpdateInfo.updatedObject);
+			return bRelevantPersistencyKey && bRelevantType && isSetDefaultChange(oUpdateInfo.updatedObject);
+		}
+	});
+
+	const oCompEntitiesDataSelector = new DataSelector({
+		id: "compEntitiesData",
+		parentDataSelector: FlexState.getFlexObjectsDataSelector(),
+		executeFunction(aFlexObjects) {
+			return aFlexObjects.filter((oFlexObject) => oFlexObject.getFileType() === "variant" ||
+				(
+					oFlexObject.getFileType() === "change"
+					&& aCompVariantChangeTypes.includes(oFlexObject.getChangeType())
+				)
+			);
+		},
+		checkInvalidation(mParameters, oUpdateInfo) {
+			const oFlexObject = oUpdateInfo.updatedObject;
+			const aRelevantUpdateTypes = ["addFlexObject", "updateFlexObject", "removeFlexObject"];
+			const bIsRelevantUpdateType = aRelevantUpdateTypes.includes(oUpdateInfo.type);
+			const bIsChangeWithRelevantChangeType = oFlexObject.getFileType() === "change" &&
+				aCompVariantChangeTypes.includes(oFlexObject.getChangeType());
+			const bIsVariantFileType = oUpdateInfo.updatedObject?.getFileType?.() === "variant";
+			return bIsRelevantUpdateType && (bIsVariantFileType || bIsChangeWithRelevantChangeType);
+		}
+	});
+
+	const oVariantsDataSelector = new DataSelector({
+		id: "compVariantData",
+		parameterKey: "persistencyKey",
+		parentDataSelector: oCompEntitiesDataSelector,
+		executeFunction(aFlexObjects, mPropertyBag) {
+			const aVariants = aFlexObjects.filter((oFlexObject) =>
+				oFlexObject.getFileType() === "variant"
+				&& oFlexObject.getPersistencyKey() === mPropertyBag.persistencyKey
+				&& (oFlexObject.getState() !== States.LifecycleState.DELETED || mPropertyBag.includeDeleted)
+			);
+
+			return CompVariantManagementState.applyChangesOnVariants(mPropertyBag.reference, mPropertyBag.persistencyKey, aVariants);
+		},
+		checkInvalidation(mParameters, oUpdateInfo) {
+			const oFlexObject = oUpdateInfo.updatedObject;
+			const aRelevantUpdateTypes = ["addFlexObject", "updateFlexObject", "removeFlexObject"];
+			const bIsRelevantUpdateType = aRelevantUpdateTypes.includes(oUpdateInfo.type);
+			const bIsChangeWithRelevantChangeType = oFlexObject.getFileType() === "change" &&
+				aCompVariantChangeTypes.includes(oFlexObject.getChangeType());
+			const bIsVariantFileType = oUpdateInfo.updatedObject?.getFileType?.() === "variant";
+			return bIsRelevantUpdateType && (bIsVariantFileType || bIsChangeWithRelevantChangeType);
 		}
 	});
 
+	// comp entities may hold the persistency key within the persistencyKey property (variant) or within the selector (changes)
+	const oCompEntitiesByPersistencyKeyDataSelector = new DataSelector({
+		id: "compEntitiesByPersistencyKey",
+		parameterKey: "persistencyKey",
+		parentDataSelector: oCompEntitiesDataSelector,
+		executeFunction(aFlexObjects, mPropertyBag) {
+			return aFlexObjects.filter((oFlexObject) =>
+				(oFlexObject.getPersistencyKey?.() || oFlexObject.getSelector?.().persistencyKey) === mPropertyBag.persistencyKey
+			);
+		},
+		checkInvalidation(mParameters, oUpdateInfo) {
+			const oFlexObject = oUpdateInfo.updatedObject;
+			return (oFlexObject?.getPersistencyKey?.() || oFlexObject.getSelector?.().persistencyKey) === mParameters.persistencyKey;
+		}
+	});
+
+	const oChangesByVariantIdsDataSelector = new DataSelector({
+		id: "getChangesByVariantIds",
+		parentDataSelector: oCompEntitiesByPersistencyKeyDataSelector,
+		executeFunction(aFlexObjects) {
+			const mChanges = {};
+			const aVariantIds = aFlexObjects
+			.filter((oFlexObject) => oFlexObject.getFileType() === "variant")
+			.map((oVariant) => oVariant.getVariantId());
+
+			aFlexObjects.filter((oFlexObject) => oFlexObject.getFileType() === "change" && oFlexObject.getChangeType() !== "defaultVariant")
+			.forEach(function(oChange) {
+				const sVariantId = escapeSpecialIdCharacters(oChange.getSelector().variantId || oChange.getContent().key);
+				if (aVariantIds.includes(sVariantId)) {
+					mChanges[sVariantId] ||= [];
+					mChanges[sVariantId].push(oChange);
+				} else if (oChange.getChangeType() === "standardVariant") {
+					mChanges[CompVariant.STANDARD_VARIANT_ID] ||= [];
+					mChanges[CompVariant.STANDARD_VARIANT_ID].push(oChange);
+				}
+			});
+
+			return mChanges;
+		}
+	});
+
+	function createVariant(mPropertyBag) {
+		const oVariantInput = mPropertyBag.variantInput || {};
+		const oVariantData = {
+			fileName: oVariantInput.fileName,
+			fileType: "variant",
+			variantId: oVariantInput.id || CompVariant.STANDARD_VARIANT_ID,
+			persisted: oVariantInput.persisted,
+			reference: mPropertyBag.reference,
+			favorite: oVariantInput.favorite,
+			executeOnSelection: oVariantInput.executeOnSelection,
+			adaptationId: oVariantInput.adaptationId,
+			content: oVariantInput.content || {},
+			texts: {
+				variantName: {
+					value: oVariantInput.name || ""
+				}
+			},
+			selector: {
+				persistencyKey: mPropertyBag.persistencyKey
+			}
+		};
+
+		return FlexObjectFactory.createCompVariant(oVariantData);
+	}
+
+	function escapeSpecialIdCharacters(sId) {
+		return sId?.replace("#", "_HASHTAG_");
+	}
+
+	CompVariantManagementState.applyChangesOnVariants = function(sReference, sPersistencyKey, aVariants) {
+		const mChangesByVariantId = oChangesByVariantIdsDataSelector.get({
+			reference: sReference,
+			persistencyKey: sPersistencyKey
+		});
+		aVariants.forEach((oVariant) => {
+			const aChangesOnVariant = mChangesByVariantId[oVariant.getVariantId()] || [];
+			if (aChangesOnVariant.length > 0) {
+				applyChangesOnVariant(oVariant, aChangesOnVariant);
+				oCompEntitiesDataSelector.checkUpdate(
+					{ reference: sReference },
+					[{ type: "updateFlexObject", updatedObject: oVariant }]
+				);
+			}
+		});
+
+		return aVariants;
+	};
+
+	/**
+	 * Access to the variant management comp entities selector.
+	 *
+	 * @returns {object} The data selector for the variants and their changes
+	 *
+	 * @private
+	 * @ui5-restricted sap.ui.fl.qunit
+	 */
+	CompVariantManagementState.getCompEntitiesDataSelector = function() {
+		return oCompEntitiesDataSelector;
+	};
+
 	/**
 	 * Access to the variant management set default selector.
 	 *
@@ -67,7 +233,7 @@ sap.ui.define([
 	 *
 	 * @param {object} mPropertyBag Object with the necessary properties
 	 * @param {string} mPropertyBag.persistencyKey - Persistency key of the variant management
-	 * @param {string} mPropertyBag.reference - Component reference
+	 * @param {string} mPropertyBag.reference - Flexibility reference of the app
 	 * @param {sap.ui.fl.apply._internal.flexObjects.CompVariant[]} mPropertyBag.variants - Array of variants which exist for the given variant management
 	 *
 	 * @returns {string | undefined} ID of the default variant
@@ -82,17 +248,95 @@ sap.ui.define([
 
 		mPropertyBag.persistencyKey = String(mPropertyBag.persistencyKey);
 		const aDefaultChanges = [...oSetDefaultDataSelector.get(mPropertyBag)].reverse();
-		const aDefaultVariantIds = aDefaultChanges.map((oChange) => oChange.getContent().defaultVariantName);
+		const aDefaultVariantIds = aDefaultChanges
+		.map((oChange) => oChange.getContent().defaultVariantName)
+		.map((sId) => escapeSpecialIdCharacters(sId));
 
 		return aDefaultVariantIds.find((sDefaultVariantId) => aVariantIds.includes(sDefaultVariantId)) || "";
 	};
 
 	/**
-	 * Returns the 'defaultVariant' changes for a given variant management
+	 * Returns all variants saved in the FlexState.
+	 *
+	 * @param {object} mPropertyBag - Object with the necessary properties
+	 * @param {string} mPropertyBag.reference - Flex reference of the current app
+	 * @param {string} mPropertyBag.persistencyKey - Persistency key of the variant management
+	 * @param {object} mPropertyBag.standardVariant - The standard variant passed by the control
+	 * @param {string} mPropertyBag.componentId - The ID of the application component
+	 * @param {boolean} [mPropertyBag.includeDeleted=false] - Flag if also deleted variants should be returned
+	 *
+	 * @returns {sap.ui.fl.apply._internal.flexObjects.CompVariant[]} Array of variants
+	 */
+	CompVariantManagementState.assembleVariantList = function(mPropertyBag) {
+		let oStandardVariant = oVariantsDataSelector.get(mPropertyBag).findLast((oVariant) => oVariant.getStandardVariant());
+
+		if (!oStandardVariant) {
+			oStandardVariant = createVariant({
+				reference: mPropertyBag.reference,
+				persistencyKey: mPropertyBag.persistencyKey,
+				variantInput: mPropertyBag.standardVariant,
+				standardVariant: true
+			});
+			FlexState.addRuntimeSteadyObject(mPropertyBag.reference, mPropertyBag.componentId, oStandardVariant);
+		}
+
+		return oVariantsDataSelector.get(mPropertyBag).filter((oVariant) => oVariant.getVisible());
+	};
+
+	/**
+	 * Returns a variant saved in the flex state.
 	 *
 	 * @param {object} mPropertyBag Object with the necessary properties
+	 * @param {string} mPropertyBag.reference - Flex reference of the current app
 	 * @param {string} mPropertyBag.persistencyKey - Persistency key of the variant management
-	 * @param {string} mPropertyBag.reference - Component reference
+	 * @param {string} mPropertyBag.id - ID of the variant
+	 * @param {string} mPropertyBag.componentId - The ID of the application component
+	 *
+	 * @returns {sap.ui.fl.apply._internal.flexObjects.CompVariant | undefined} Variant or undefined if the variant cannot be found
+	 */
+	CompVariantManagementState.getVariant = function(mPropertyBag) {
+		return oVariantsDataSelector.get(mPropertyBag).find((oVariant) => oVariant.getVariantId() === mPropertyBag.id);
+	};
+
+	/**
+	 * Returns all changes for a given variant saved in the FlexState.
+	 *
+	 * @param {sap.ui.fl.apply._internal.flexObjects.CompVariant} oVariant - Variant for which the changes should be retrieved
+	 *
+	 * @returns {sap.ui.fl.apply._internal.flexObjects.UIChange[]} List of changes for the variant
+	 */
+	CompVariantManagementState.getVariantChanges = function(oVariant) {
+		const sReference = oVariant.getFlexObjectMetadata().reference;
+		const sVariantId = oVariant.getVariantId();
+		const sPersistencyKey = oVariant.getPersistencyKey();
+		return oChangesByVariantIdsDataSelector.get({
+			reference: sReference,
+			persistencyKey: sPersistencyKey
+		})?.[sVariantId] || [];
+	};
+
+	CompVariantManagementState.addExternalVariants = function(mPropertyBag) {
+		try {
+			mPropertyBag.variants?.map((oVariant) => {
+				oVariant.reference = mPropertyBag.reference;
+				oVariant.fileName = escapeSpecialIdCharacters(oVariant.id); // external oData Variants may have an invalid ID for ManagedObjects
+				oVariant.selector = {persistencyKey: mPropertyBag.persistencyKey};
+				oVariant.texts = {variantName: {value: oVariant.name}};
+				return oVariant;
+			})
+			.map((oVariant) => FlexObjectFactory.createFromFileContent(oVariant, CompVariant, true))
+			.forEach((oFlexObject) => FlexState.addRuntimeSteadyObject(mPropertyBag.reference, mPropertyBag.componentId, oFlexObject));
+		} catch (oError) {
+			Log.error(`External comp variant could not be added: ${oError.message}`);
+		}
+	};
+
+	/**
+	 * Returns the 'defaultVariant' changes for a given variant management
+	 *
+	 * @param {object} mPropertyBag - Object with the necessary properties
+	 * @param {string} mPropertyBag.persistencyKey - Persistency key of the variant management
+	 * @param {string} mPropertyBag.reference - Flexibility reference of the app
 	 *
 	 * @returns {sap.ui.fl.apply._internal.flexObjects.UpdatableChange[]} 'defaultVariant' changes of the variant management
 	 *
@@ -104,5 +348,38 @@ sap.ui.define([
 		return oSetDefaultDataSelector.get(mPropertyBag);
 	};
 
+	/**
+	 * Returns the all sap.ui.comp related entities for a given reference
+	 *
+	 * @param {object} mPropertyBag Object with the necessary properties
+	 * @param {string} mPropertyBag.reference - Flexibility reference of the app
+	 *
+	 * @returns {sap.ui.fl.apply._internal.flexObjects.FlexObject[]} - All comp variants for a given reference
+	 *
+	 * @since 1.140
+	 * @private
+	 * @ui5-restricted sap.ui.fl
+	 */
+	CompVariantManagementState.getCompEntities = (mPropertyBag) => {
+		return oCompEntitiesDataSelector.get(mPropertyBag);
+	};
+
+	/**
+	 * Returns the all sap.ui.comp related entities for a given reference and persistency key
+	 *
+	 * @param {object} mPropertyBag Object with the necessary properties
+	 * @param {string} mPropertyBag.reference - Flexibility reference of the app
+	 * @param {string} mPropertyBag.persistencyKey - Persistency key of the variant management
+	 *
+	 * @returns {sap.ui.fl.apply._internal.flexObjects.FlexObject[]} - all sap.ui.comp related entities for a given reference
+	 *
+	 * @since 1.140
+	 * @private
+	 * @ui5-restricted sap.ui.fl
+	 */
+	CompVariantManagementState.getCompEntitiesByPersistencyKey = (mPropertyBag) => {
+		return oCompEntitiesByPersistencyKeyDataSelector.get(mPropertyBag);
+	};
+
 	return CompVariantManagementState;
 });

package/src/sap/ui/fl/apply/_internal/flexState/compVariants/applyChangesOnVariant.js

@@ -0,0 +1,61 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2025 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
+sap.ui.define([
+	"sap/base/Log"
+], function(
+	Log
+) {
+	"use strict";
+
+	var mChangeHandlers = {
+		addFavorite(oVariant) {
+			oVariant.setFavorite(true);
+		},
+		removeFavorite(oVariant) {
+			oVariant.setFavorite(false);
+		},
+		updateVariant(oVariant, oChange) {
+			var oChangeContent = oChange.getContent();
+			if (oChangeContent.executeOnSelection !== undefined) {
+				oVariant.setExecuteOnSelection(oChangeContent.executeOnSelection);
+			}
+			if (oChangeContent.favorite !== undefined) {
+				oVariant.setFavorite(oChangeContent.favorite);
+			}
+			if (oChangeContent.contexts) {
+				oVariant.setContexts(oChangeContent.contexts);
+			}
+			if (oChangeContent.visible !== undefined) {
+				oVariant.setVisible(oChangeContent.visible);
+			}
+
+			if (oChangeContent.variantContent) {
+				oVariant.setContent(oChangeContent.variantContent, /* bSkipStateChange = */ true);
+			}
+			var sVariantName = oChange.getText("variantName");
+			if (sVariantName) {
+				oVariant.setName(sVariantName, /* bSkipStateChange = */ true);
+			}
+		},
+		standardVariant(oVariant, oChange) {
+			// legacy change on standard variants
+			oVariant.setExecuteOnSelection(oChange.getContent().executeOnSelect);
+		}
+	};
+
+	function logNoChangeHandler(oVariant, oChange) {
+		Log.error(`No change handler for change with the ID '${oChange.getId()}' and type '${oChange.getChangeType()}' defined.
+			The variant '${oVariant.getId()}'was not modified'`);
+	}
+
+	return (oVariant, aChanges = []) => {
+		aChanges.forEach(function(oChange) {
+			var oChangeHandler = mChangeHandlers[oChange.getChangeType()] || logNoChangeHandler;
+			oChangeHandler(oVariant, oChange);
+		});
+	};
+});

package/src/sap/ui/fl/apply/_internal/flexState/controlVariants/Switcher.js

@@ -8,12 +8,16 @@ sap.ui.define([
 	"sap/base/util/restricted/_pick",
 	"sap/ui/fl/apply/_internal/changes/Applier",
 	"sap/ui/fl/apply/_internal/changes/Reverter",
-	"sap/ui/fl/apply/_internal/flexState/controlVariants/VariantManagementState"
+	"sap/ui/fl/apply/_internal/flexState/changes/DependencyHandler",
+	"sap/ui/fl/apply/_internal/flexState/controlVariants/VariantManagementState",
+	"sap/ui/fl/apply/_internal/flexState/FlexObjectState"
 ], function(
 	_pick,
 	Applier,
 	Reverter,
-	VariantManagementState
+	DependencyHandler,
+	VariantManagementState,
+	FlexObjectState
 ) {
 	"use strict";
 
@@ -75,7 +79,7 @@ sap.ui.define([
 	 *
 	 * @namespace sap.ui.fl.apply._internal.flexState.controlVariants.Switcher
 	 * @since 1.74
-	 * @version 1.139.0
+	 * @version 1.141.0
 	 * @private
 	 * @ui5-restricted
 	 */
@@ -97,8 +101,21 @@ sap.ui.define([
 		async switchVariant(mPropertyBag) {
 			var mChangesToBeSwitched = getControlChangesForVariantSwitch(mPropertyBag);
 
-			await Reverter.revertMultipleChanges(mChangesToBeSwitched.changesToBeReverted, mPropertyBag);
-			await Applier.applyMultipleChanges(mChangesToBeSwitched.changesToBeApplied, mPropertyBag);
+			const oLiveDependencyMap = FlexObjectState.getLiveDependencyMap(mPropertyBag.reference);
+
+			// Early setting the changes as queued for revert/apply prevents potential timing issues
+			// when e.g. evaluating the App State after the switch
+			mChangesToBeSwitched.changesToBeReverted.forEach((oChange) => oChange.setQueuedForRevert());
+			mChangesToBeSwitched.changesToBeApplied.forEach((oChange) => {
+				if (!oChange.isApplyProcessFinished()) {
+					oChange.setQueuedForApply();
+					// Add change to the dependency map in advance so that any dependent changes are aware of the change
+					DependencyHandler.addRuntimeChangeToMap(oChange, mPropertyBag.appComponent, oLiveDependencyMap);
+				}
+			});
+
+			await Reverter.revertMultipleChanges(mChangesToBeSwitched.changesToBeReverted, {...mPropertyBag, skipSetQueued: true});
+			await Applier.applyMultipleChanges(mChangesToBeSwitched.changesToBeApplied, {...mPropertyBag, skipSetQueued: true});
 			VariantManagementState.setCurrentVariant(mPropertyBag);
 		}
 

package/src/sap/ui/fl/apply/_internal/flexState/controlVariants/VariantManagementState.js

@@ -14,7 +14,6 @@ sap.ui.define([
 	"sap/ui/fl/apply/_internal/flexState/DataSelector",
 	"sap/ui/fl/apply/_internal/flexState/FlexState",
 	"sap/ui/fl/changeHandler/condenser/Classification",
-	"sap/ui/fl/initial/_internal/Storage",
 	"sap/ui/fl/LayerUtils"
 ], function(
 	_omit,
@@ -26,7 +25,6 @@ sap.ui.define([
 	DataSelector,
 	FlexState,
 	Classification,
-	Storage,
 	LayerUtils
 ) {
 	"use strict";
@@ -55,7 +53,7 @@ sap.ui.define([
 	 *
 	 * @namespace sap.ui.fl.apply._internal.flexState.controlVariants.VariantManagementState
 	 * @since 1.74
-	 * @version 1.139.0
+	 * @version 1.141.0
 	 * @private
 	 * @ui5-restricted
 	 */
@@ -235,9 +233,9 @@ sap.ui.define([
 		return oGroupedFlexObjects;
 	}
 
-	function createVariantsMap(aFlexObjects) {
+	function createVariantsMap(aFlexObjects, mPropertyBag) {
 		const oGroupedFlexObjects = groupFlexObjects(aFlexObjects);
-		const sReference = aFlexObjects[0]?.getFlexObjectMetadata().reference;
+		const sReference = mPropertyBag.reference;
 
 		const oVariantManagementsMap = {};
 		oGroupedFlexObjects.variants.forEach((oVariantInstance) => {
@@ -346,8 +344,8 @@ sap.ui.define([
 				return true;
 			}
 
-			const aRelevantFlexObjectTypes = ["addFlexObject", "updateFlexObject", "removeFlexObject"];
-			const bRelevantType = aRelevantFlexObjectTypes.includes(oUpdateInfo.type);
+			const aRelevantFlexObjectUpdateTypes = ["addFlexObject", "updateFlexObject", "removeFlexObject"];
+			const bRelevantType = aRelevantFlexObjectUpdateTypes.includes(oUpdateInfo.type);
 			const aRelevantVariantFileTypes = ["ctrl_variant", "ctrl_variant_change", "ctrl_variant_management_change"];
 			const bRelevantVariantType = aRelevantVariantFileTypes.includes(oUpdateInfo.updatedObject?.getFileType?.());
 			const bHasVariantReference = oUpdateInfo.updatedObject?.getVariantReference?.();
@@ -495,14 +493,10 @@ sap.ui.define([
 	 * @param {string} mPropertyBag.variantReference - Variant reference to be loaded
 	 */
 	VariantManagementState.loadVariant = async function(mPropertyBag) {
-		const oStorageResponse = await Storage.loadFlVariant({
+		await FlexState.lazyLoadFlVariant({
 			variantReference: mPropertyBag.variantReference,
 			reference: mPropertyBag.reference
 		});
-		FlexState.updateWithDataProvided({
-			reference: mPropertyBag.reference,
-			newData: oStorageResponse
-		});
 	};
 
 	/**
@@ -576,20 +570,43 @@ sap.ui.define([
 		});
 	};
 
+	VariantManagementState.updateVariant = function(mPropertyBag) {
+		oVariantManagementMapDataSelector.checkUpdate(
+			{ reference: mPropertyBag.reference },
+			[{ type: "updateFlexObject", updatedObject: mPropertyBag.variant }]
+		);
+	};
+
 	/**
 	 * Returns the current variant reference for a given variant management reference.
 	 *
 	 * @param {object} mPropertyBag - Object with the necessary properties
 	 * @param {string} mPropertyBag.vmReference - Variant management reference
 	 * @param {string} mPropertyBag.reference - Component reference
-	 * @returns {string} Reference of the current variant
+	 * @returns {string | undefined} Reference of the current variant or undefined if VM does not exist
 	 */
 	VariantManagementState.getCurrentVariantReference = function(mPropertyBag) {
 		var oVariantManagementSection = oVariantManagementsDataSelector.get({
 			variantManagementReference: mPropertyBag.vmReference,
 			reference: mPropertyBag.reference
 		});
-		return oVariantManagementSection.currentVariant;
+		return oVariantManagementSection?.currentVariant;
+	};
+
+	/**
+	 * Returns the default variant reference for a given variant management reference.
+	 *
+	 * @param {object} mPropertyBag - Object with the necessary properties
+	 * @param {string} mPropertyBag.vmReference - Variant management reference
+	 * @param {string} mPropertyBag.reference - Component reference
+	 * @returns {string | undefined} Reference of the default variant or undefined if VM does not exist
+	 */
+	VariantManagementState.getDefaultVariantReference = function(mPropertyBag) {
+		const oVariantManagement = oVariantManagementsDataSelector.get({
+			variantManagementReference: mPropertyBag.vmReference,
+			reference: mPropertyBag.reference
+		});
+		return oVariantManagement?.defaultVariant;
 	};
 
 	/**
@@ -625,6 +642,24 @@ sap.ui.define([
 		return Object.keys(oVariantsMap);
 	};
 
+	/**
+	 * Returns the variant management reference for a given variant reference.
+	 *
+	 * @param {string} sReference - Flex reference of the current app
+	 * @param {string} sVariantReference - Variant reference to search for
+	 * @returns {string | undefined} Variant management reference if found, otherwise undefined
+	 */
+	VariantManagementState.getVariantManagementReferenceForVariant = function(sReference, sVariantReference) {
+		const oVariantsMap = oVariantManagementMapDataSelector.get({
+			reference: sReference
+		});
+		return Object.entries(oVariantsMap).find(([, oVM]) => {
+			return oVM.variants.some((oVariant) => {
+				return oVariant.key === sVariantReference;
+			});
+		})?.[0];
+	};
+
 	/**
 	 * Returns all variants saved in the FlexState.
 	 *
@@ -791,26 +826,44 @@ sap.ui.define([
 	};
 
 	/**
-	 * Sets the promise for the variant switch for the given reference.
+	 * Sets the promise for the variant switch for the given flex reference and VM reference.
 	 *
 	 * @param {string} sReference - Flex reference of the app
-	 * @param {Promise<undefined>} oPromise - Variant Switch Promise
 	 * @param {string} sVMReference - Variant Management reference
+	 * @param {Promise<undefined>} oPromise - Variant Switch Promise
 	 */
-	VariantManagementState.setVariantSwitchPromise = function(sReference, oPromise, sVMReference) {
+	VariantManagementState.setVariantSwitchPromise = function(sReference, sVMReference, oPromise) {
 		mVariantSwitchPromises[sReference] ||= {};
 		mVariantSwitchPromises[sReference][sVMReference] = oPromise;
 	};
 
 	/**
-	 * Gets the promise for the variant switch for the given reference.
+	 * Waits for the variant switch of a given VM.
 	 *
 	 * @param {string} sReference - Flex reference of the app
+	 * @param {string} sVMReference - Variant Management reference
 	 * @returns {Promise<undefined>} Variant Switch Promise
 	 */
-	VariantManagementState.waitForVariantSwitch = function(sReference) {
+	VariantManagementState.waitForVariantSwitch = function(sReference, sVMReference) {
+		return mVariantSwitchPromises[sReference]?.[sVMReference] || Promise.resolve();
+	};
+
+	/**
+	 * Waits for all variant switches for the given flex reference.
+	 *
+	 * @param {string} sReference - Flex reference of the app
+	 * @returns {Promise<undefined>} Variant Switches Promise
+	 */
+	VariantManagementState.waitForAllVariantSwitches = function(sReference) {
 		return Promise.all(Object.values(mVariantSwitchPromises[sReference] || {}));
 	};
 
+	VariantManagementState.getVariantsForVariantManagement = function(mPropertyBag) {
+		const oVariantManagement = oVariantManagementsDataSelector.get({
+			variantManagementReference: mPropertyBag.vmReference,
+			reference: mPropertyBag.reference
+		});
+		return oVariantManagement?.variants || [];
+	};
 	return VariantManagementState;
 });