@openui5/sap.ui.fl 1.139.0 → 1.141.0

package/src/sap/ui/fl/initial/_internal/Loader.js

@@ -0,0 +1,372 @@
+/*!
+ * 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/util/Deferred",
+	"sap/base/util/merge",
+	"sap/base/util/ObjectPath",
+	"sap/base/Log",
+	"sap/ui/base/ManagedObject",
+	"sap/ui/fl/initial/_internal/FlexInfoSession",
+	"sap/ui/fl/initial/_internal/ManifestUtils",
+	"sap/ui/fl/initial/_internal/Settings",
+	"sap/ui/fl/initial/_internal/Storage",
+	"sap/ui/fl/initial/_internal/StorageUtils"
+], function(
+	Deferred,
+	merge,
+	ObjectPath,
+	Log,
+	ManagedObject,
+	FlexInfoSession,
+	ManifestUtils,
+	Settings,
+	Storage,
+	StorageUtils
+) {
+	"use strict";
+
+	const _mCachedFlexData = {};
+	const _mInitPromises = {};
+
+	/**
+	 * Class for loading Flex Data from the backend via the Connectors.
+	 *
+	 * @namespace sap.ui.fl.apply._internal.flexState.Loader
+	 * @since 1.74
+	 * @version 1.141.0
+	 * @private
+	 * @ui5-restricted sap.ui.fl.apply._internal.flexState
+	 */
+	const Loader = {};
+
+	function getIdIsLocalTrueObject(vSelector) {
+		if (typeof vSelector === "string") {
+			vSelector = {id: vSelector};
+		}
+		vSelector.idIsLocal = true;
+
+		return vSelector;
+	}
+
+	function migrateOVPSelectorFlags(oManifest, mFlexData) {
+		if (ManifestUtils.getOvpEntry(oManifest)) {
+			[
+				mFlexData.changes,
+				mFlexData.variantChanges,
+				mFlexData.variantDependentControlChanges,
+				mFlexData.variantManagementChanges
+			]
+			.flat()
+			.filter((oFlexObject) => (
+				oFlexObject.selector
+				&& !oFlexObject.selector.idIsLocal
+			))
+			.forEach(function(oFlexObject) {
+				oFlexObject.selector = getIdIsLocalTrueObject(oFlexObject.selector);
+
+				if (oFlexObject.dependentSelector) {
+					Object.keys(oFlexObject.dependentSelector).forEach((sCategory) => {
+						const vDependentSelector = oFlexObject.dependentSelector[sCategory];
+						if (Array.isArray(vDependentSelector)) {
+							oFlexObject.dependentSelector[sCategory] = vDependentSelector.map(getIdIsLocalTrueObject);
+						} else {
+							oFlexObject.dependentSelector[sCategory] = getIdIsLocalTrueObject(vDependentSelector);
+						}
+					});
+				}
+			});
+		}
+
+		return mFlexData;
+	}
+
+	function filterInvalidFileNames(mFlexData) {
+		StorageUtils.getAllFlexObjectNamespaces().forEach(function(vKey) {
+			const aFlexItems = ObjectPath.get(vKey, mFlexData);
+			if (aFlexItems) {
+				ObjectPath.set(vKey, aFlexItems.filter((oFlexItem) => {
+					let oTemporaryInstance;
+					try {
+						oTemporaryInstance = new ManagedObject(oFlexItem.fileName);
+					} catch (error) {
+						return false;
+					}
+					oTemporaryInstance.destroy();
+					return true;
+				}), mFlexData);
+			}
+		});
+		return mFlexData;
+	}
+
+	function getSideId(oComponentData) {
+		if (oComponentData?.startupParameters && Array.isArray(oComponentData.startupParameters.hcpApplicationId)) {
+			return oComponentData.startupParameters.hcpApplicationId[0];
+		}
+	}
+
+	/**
+	 * Removes the changes that should be deactivated and the deactivate changes from the Flex Data.
+	 * This is the equivalent of deleting changes from the backend.
+	 * Example Scenario: When creating an annotation rename change, any control based rename changes should be removed.
+	 * But Developer changes can't be deleted from the backend, so they are deactivated.
+	 *
+	 * @param {object} mFlexData - Flex Data as returned from the Storage
+	 * @returns {object} Flex Data without the deactivate and deactivated changes
+	 */
+	function applyDeactivateChanges(mFlexData) {
+		const sDeactivateChangeType = "deactivateChanges";
+		const aToBeDeactivatedIds = mFlexData.changes.map((oChange) => {
+			if (oChange.changeType === sDeactivateChangeType) {
+				return [oChange.fileName, ...oChange.content.changeIds];
+			}
+		})
+		.flat()
+		.filter(Boolean);
+
+		// Filter all changes that should be deactivated (also already includes the id of the deactivate changes)
+		if (aToBeDeactivatedIds.length) {
+			StorageUtils.getAllFlexObjectNamespaces().forEach(function(vKey) {
+				const aFlexItems = ObjectPath.get(vKey, mFlexData);
+				if (aFlexItems.length) {
+					ObjectPath.set(vKey, aFlexItems.filter((oFlexItem) => !aToBeDeactivatedIds.includes(oFlexItem.fileName)), mFlexData);
+				}
+			});
+		}
+		return mFlexData;
+	}
+
+	/**
+	 * Provides the flex data for a given application based on the configured connectors.
+	 * This function needs a manifest object, async hints and either an ID to an instantiated component or component data as parameter.
+	 * The fetched data is cached statically in the Loader class. Together with the data, all parameters that have been used
+	 * for the request are cached as well. If the function is called again with the same parameters,
+	 * the cached data is returned instead of a new request to the backend.
+	 *
+	 * @param {object} mPropertyBag - Contains additional data needed for loading changes
+	 * @param {object} mPropertyBag.manifest - ManifestObject that belongs to current component
+	 * @param {string} mPropertyBag.reference - Flex Reference
+	 * @param {object} mPropertyBag.componentData - Component data of the current component
+	 * @param {boolean} [mPropertyBag.reInitialize] - Flag if the application is reinitialized even if it was loaded before
+	 * @param {object} [mPropertyBag.asyncHints] - Async hints passed from the app index to the component processing
+	 * @param {boolean} [mPropertyBag.skipLoadBundle=false] - If true only the partial flex data is loaded, without the bundle
+	 * @returns {Promise<object>} Resolves with the change file for the given component from the Storage
+	 */
+	Loader.getFlexData = async function(mPropertyBag) {
+		// the FlexInfoSession is used to adjust the parameters of the request
+		let oFlexInfoSession = FlexInfoSession.getByReference(mPropertyBag.reference);
+		const mPropertyBagCopy = merge({}, mPropertyBag, {
+			version: oFlexInfoSession.version,
+			adaptationId: oFlexInfoSession.displayedAdaptationId,
+			allContextsProvided: oFlexInfoSession.allContextsProvided
+		});
+		const sReference = mPropertyBagCopy.reference;
+
+		const oOldInitPromise = _mInitPromises[sReference];
+		const oNewInitPromise = new Deferred();
+		_mInitPromises[sReference] = oNewInitPromise;
+
+		if (oOldInitPromise) {
+			await oOldInitPromise.promise;
+		}
+
+		const bRequiresNewLoadRequest =
+			mPropertyBag.reInitialize
+			|| !_mCachedFlexData[mPropertyBag.reference]
+			|| _mCachedFlexData[sReference].parameters.emptyState
+			|| _mCachedFlexData[sReference].parameters.version !== mPropertyBagCopy.version
+			|| _mCachedFlexData[sReference].parameters.allContextsProvided !== mPropertyBagCopy.allContextsProvided
+			|| _mCachedFlexData[sReference].parameters.adaptationId !== mPropertyBagCopy.adaptationId;
+
+		const bRequiresOnlyCompletion =
+			_mCachedFlexData[sReference]
+			&& !_mCachedFlexData[sReference].parameters.emptyState
+			&& _mCachedFlexData[sReference].parameters.bundleNotLoaded
+			&& !mPropertyBagCopy.skipLoadBundle;
+
+		if (!bRequiresNewLoadRequest && !bRequiresOnlyCompletion) {
+			oNewInitPromise.resolve();
+			return {
+				data: _mCachedFlexData[sReference].data,
+				cacheInvalidated: false
+			};
+		}
+
+		let oFlexData;
+		let oAuthors;
+		const sComponentName = ManifestUtils.getBaseComponentNameFromManifest(mPropertyBagCopy.manifest);
+		if (bRequiresNewLoadRequest) {
+			// the cache key cannot be used in case of a reinitialization
+			const sCacheKey = mPropertyBagCopy.reInitialize
+				? undefined
+				: ManifestUtils.getCacheKeyFromAsyncHints(sReference, mPropertyBagCopy.asyncHints);
+
+			oFlexData = await Storage.loadFlexData({
+				preview: ManifestUtils.getPreviewSectionFromAsyncHints(mPropertyBagCopy.asyncHints),
+				reference: sReference,
+				componentName: sComponentName,
+				cacheKey: sCacheKey,
+				siteId: getSideId(mPropertyBagCopy.componentData),
+				appDescriptor: mPropertyBagCopy.manifest.getRawJson ? mPropertyBagCopy.manifest.getRawJson() : mPropertyBagCopy.manifest,
+				version: mPropertyBagCopy.version,
+				adaptationId: mPropertyBagCopy.adaptationId,
+				skipLoadBundle: mPropertyBagCopy.skipLoadBundle
+			});
+			const oSettings = await Settings.getInstance();
+			oAuthors = oSettings.getIsVariantAuthorNameAvailable() ? await Storage.loadVariantsAuthors(sReference) : {};
+		} else {
+			oFlexData = await Storage.completeFlexData({
+				reference: sReference,
+				componentName: sComponentName,
+				partialFlexData: _mCachedFlexData[sReference].data.changes
+			});
+			oAuthors = _mCachedFlexData[sReference].data.authors;
+		}
+
+		const oFlexDataCopy = Object.assign({}, oFlexData);
+		applyDeactivateChanges(oFlexDataCopy);
+		filterInvalidFileNames(oFlexDataCopy);
+		migrateOVPSelectorFlags(mPropertyBagCopy.manifest, oFlexDataCopy);
+
+		const oFormattedFlexData = {
+			changes: oFlexDataCopy,
+			cacheKey: oFlexDataCopy.cacheKey,
+			authors: oAuthors
+		};
+
+		_mCachedFlexData[sReference] = {
+			data: oFormattedFlexData,
+			parameters: {
+				bundleNotLoaded: !!mPropertyBagCopy.skipLoadBundle,
+				version: mPropertyBagCopy.version,
+				allContextsProvided: mPropertyBagCopy.allContextsProvided,
+				adaptationId: mPropertyBagCopy.adaptationId
+			}
+		};
+
+		if (oFormattedFlexData.changes.info !== undefined) {
+			oFlexInfoSession = { ...oFlexInfoSession, ...oFormattedFlexData.changes.info };
+		}
+		FlexInfoSession.setByReference(oFlexInfoSession, sReference);
+		oNewInitPromise.resolve();
+		return {
+			data: oFormattedFlexData,
+			cacheInvalidated: true
+		};
+	};
+
+	/**
+	 * Initializes an empty cache for a specific reference.
+	 *
+	 * @param {string} sReference - The flex reference for which to initialize the cache.
+	 * @returns {object} The empty Flex Data object
+	 */
+	Loader.initializeEmptyCache = function(sReference) {
+		const oInitialFlexData = { changes: StorageUtils.getEmptyFlexDataResponse() };
+		_mCachedFlexData[sReference] = {
+			data: oInitialFlexData,
+			parameters: {
+				bundleNotLoaded: true,
+				emptyState: true
+			}
+		};
+		return oInitialFlexData;
+	};
+
+	/**
+	 * Clears the cache for a specific reference or for all references if no reference is provided.
+	 * Should only be used in tests.
+	 *
+	 * @param {string} [sReference] - The flex reference for which to clear the cache.
+	 */
+	Loader.clearCache = function(sReference) {
+		if (sReference) {
+			delete _mCachedFlexData[sReference];
+			delete _mInitPromises[sReference];
+		} else {
+			Object.keys(_mCachedFlexData).forEach((sReference) => {
+				delete _mCachedFlexData[sReference];
+				delete _mInitPromises[sReference];
+			});
+		}
+	};
+
+	/**
+	 * Loads a FlVariant and updates the cached flex data.
+	 *
+	 * @param {object} mPropertyBag - The property bag containing the variant reference and other parameters.
+	 * @param {string} mPropertyBag.variantReference - The reference of the variant to load.
+	 * @param {string} mPropertyBag.reference - The flex reference of the application.
+	 * @returns {Promise<object>} Resolves with the loaded variant data.
+	 */
+	Loader.loadFlVariant = async function(mPropertyBag) {
+		const oNewData = await Storage.loadFlVariant({
+			variantReference: mPropertyBag.variantReference,
+			reference: mPropertyBag.reference
+		});
+		Object.entries(oNewData).forEach(([sKey, vValue]) => {
+			_mCachedFlexData[mPropertyBag.reference].data.changes[sKey].push(...vValue);
+		});
+		return {
+			newData: oNewData,
+			completeData: _mCachedFlexData[mPropertyBag.reference].data
+		};
+	};
+
+	/**
+	 * Updates the storage response for a specific reference.
+	 *
+	 * @param {string} sReference - The flex reference for which to update the storage response.
+	 * @param {object[]} aUpdates - The updates to apply to the storage response.
+	 */
+	Loader.updateCachedResponse = function(sReference, aUpdates) {
+		StorageUtils.updateStorageResponse(_mCachedFlexData[sReference].data, aUpdates);
+	};
+
+	/**
+	 * Retrieves the cached flexibility data for a specific reference.
+	 *
+	 * @param {string} sReference - The flex reference for which to retrieve the cached data.
+	 * @returns {Promise<object>} A promise that resolves with the cached flexibility data or an empty object if not found.
+	 */
+	Loader.getCachedFlexData = function(sReference) {
+		// TODO return copy of the data once the CompVariantManager does not mutate it anymore
+		return _mCachedFlexData[sReference]?.data || {};
+	};
+
+	/**
+	 * Waits for the Loader to initialize the cached backend response.
+	 * If the getFlexData was not called before an error is logged and the promise resolves immediately.
+	 *
+	 * @param {string} sReference - The flex reference for which to wait for initialization.
+	 * @return {Promise<undefined>} Resolves with undefined when the initialization is complete
+	 */
+	Loader.waitForInitialization = function(sReference) {
+		const oInitPromise = _mInitPromises[sReference]?.promise;
+		if (!oInitPromise) {
+			Log.error("Loader.waitForInitialization was called before FlexState.initialize");
+			return Promise.resolve();
+		}
+		return oInitPromise;
+	};
+
+	/**
+	 * This function is temporary and will be removed once the allContextsProvided property is part of the flex/data requests in ABAP
+	 * The allContextsProvided property is not part of the initial flex/data request and needs to be set later to prevent
+	 * FlexState from being reinitialized
+	 *
+	 * @param {string} sReference - Flexibility reference of the app
+	 * @param {boolean} bAllContextsProvided - Flag to indicate if all contexts are provided
+	 */
+	Loader.setAllContextsProvided = function(sReference, bAllContextsProvided) {
+		if (_mCachedFlexData[sReference] && _mCachedFlexData[sReference].parameters.allContextsProvided === undefined) {
+			_mCachedFlexData[sReference].parameters.allContextsProvided = bAllContextsProvided;
+		}
+	};
+
+	return Loader;
+});

package/src/sap/ui/fl/{apply/_internal/flexState → initial/_internal}/ManifestUtils.js

@@ -78,7 +78,7 @@ function(
 	 *
 	 * @namespace sap.ui.fl.apply._internal.flexState.ManifestUtils
 	 * @since 1.74
-	 * @version 1.139.0
+	 * @version 1.141.0
 	 * @private
 	 */
 	var ManifestUtils = {

package/src/sap/ui/fl/initial/_internal/Settings.js

@@ -40,7 +40,7 @@ sap.ui.define([
 	 * @extends sap.ui.base.ManagedObject
 	 * @alias sap.ui.fl.initial._internal.Settings
 	 * @since 1.137
-	 * @version 1.139.0
+	 * @version 1.141.0
 	 * @private
 	 * @ui5-restricted sap.ui.fl
 	 */

package/src/sap/ui/fl/initial/_internal/Storage.js

@@ -28,7 +28,7 @@ sap.ui.define([
 	 *
 	 * @namespace sap.ui.fl.initial._internal.Storage
 	 * @since 1.67
-	 * @version 1.139.0
+	 * @version 1.141.0
 	 * @private
 	 * @ui5-restricted sap.ui.fl
 	 */

package/src/sap/ui/fl/initial/_internal/StorageFeaturesMerger.js

@@ -20,7 +20,7 @@ sap.ui.define([
 	 *
 	 * @namespace sap.ui.fl.intial._internal.StorageFeaturesMerger
 	 * @since 1.70
-	 * @version 1.139.0
+	 * @version 1.141.0
 	 * @private
 	 * @ui5-restricted sap.ui.fl.initial._internal.Storage
 	 */

package/src/sap/ui/fl/initial/_internal/StorageUtils.js

@@ -5,17 +5,19 @@
  */
 
 sap.ui.define([
+	"sap/base/util/isEmptyObject",
+	"sap/base/util/ObjectPath",
 	"sap/base/Log",
 	"sap/ui/fl/initial/_internal/FlexConfiguration",
 	"sap/ui/fl/Layer",
-	"sap/ui/fl/LayerUtils",
-	"sap/base/util/isEmptyObject"
+	"sap/ui/fl/LayerUtils"
 ], function(
+	isEmptyObject,
+	ObjectPath,
 	Log,
 	FlexConfiguration,
 	Layer,
-	LayerUtils,
-	isEmptyObject
+	LayerUtils
 ) {
 	"use strict";
 
@@ -25,7 +27,7 @@ sap.ui.define([
 	 *
 	 * @namespace sap.ui.fl.initial._internal.StorageUtils
 	 * @since 1.74
-	 * @version 1.139.0
+	 * @version 1.141.0
 	 * @private
 	 * @ui5-restricted sap.ui.fl.initial._internal.Storage, sap.ui.fl.write._internal.Storage,
 	 * 	sap.ui.fl.initial._internal.connectors.ObjectStorageConnector, sap.ui.fl.initial._internal.connectors.ObjectPathConnector
@@ -104,6 +106,34 @@ sap.ui.define([
 		});
 	}
 
+	function getChangeCategoryPath(oChangeDefinition) {
+		switch (oChangeDefinition.fileType) {
+			case "change":
+				if (oChangeDefinition.selector && oChangeDefinition.selector.persistencyKey) {
+					return ["comp", "changes"];
+				}
+				if (oChangeDefinition.variantReference) {
+					return "variantDependentControlChanges";
+				}
+				if (oChangeDefinition.appDescriptorChange) {
+					return "appDescriptorChanges";
+				}
+				return "changes";
+			case "ctrl_variant":
+				return "variants";
+			case "ctrl_variant_change":
+				return "variantChanges";
+			case "ctrl_variant_management_change":
+				return "variantManagementChanges";
+			case "variant":
+				return ["comp", "variants"];
+			case "annotation_change":
+				return "annotationChanges";
+			default:
+				return "";
+		}
+	}
+
 	/**
 	 * Loads the connectors from the given namespaces.
 	 * This function is replaced in the Vanilla Flex bundle with a custom implementation.
@@ -343,11 +373,39 @@ sap.ui.define([
 	 * @ui5-restricted sap.ui.fl
 	 */
 	StorageUtils.isStorageResponseFilled = function(oResponse) {
-		return Object.keys(oResponse || {}).some(function(sKey) {
-			if (Array.isArray(oResponse[sKey])) {
-				return oResponse[sKey].length !== 0;
+		const oUI2Available = !isEmptyObject(oResponse.ui2personalization);
+		return oUI2Available || StorageUtils.getAllFlexObjectNamespaces().some(function(sKey) {
+			return ObjectPath.get(sKey, oResponse)?.length > 0;
+		});
+	};
+
+	/**
+	 * Updates the storage response with the provided updates by directly mutating the given response.
+	 *
+	 * @param {object} oResponse - Storage response to apply the updates to.
+	 * @param {sap.ui.fl.apply._internal.flexState.dataSelector.UpdateInfo[]} aUpdates - The updates to apply to the storage response.
+	 */
+	StorageUtils.updateStorageResponse = function(oResponse, aUpdates) {
+		aUpdates.forEach((oUpdate) => {
+			if (oUpdate.type === "ui2") {
+				oResponse.changes.ui2personalization = oUpdate.newData;
+			} else {
+				const vPath = getChangeCategoryPath(oUpdate.flexObject);
+				const sFileName = oUpdate.flexObject.fileName;
+				const aCache = ObjectPath.get(vPath, oResponse.changes);
+				switch (oUpdate.type) {
+					case "add":
+						aCache.push(oUpdate.flexObject);
+						break;
+					case "delete":
+						aCache.splice(aCache.findIndex((oFlexObject) => oFlexObject.fileName === sFileName), 1);
+						break;
+					case "update":
+						aCache.splice(aCache.findIndex((oFlexObject) => oFlexObject.fileName === sFileName), 1, oUpdate.flexObject);
+						break;
+					default:
+				}
 			}
-			return !isEmptyObject(oResponse[sKey]);
 		});
 	};
 

package/src/sap/ui/fl/initial/_internal/changeHandlers/ChangeHandlerRegistration.js

@@ -84,7 +84,7 @@ sap.ui.define([
 		 * @alias sap.ui.fl.registry.ChangeHandlerRegistration
 		 *
 		 * @author SAP SE
-		 * @version 1.139.0
+		 * @version 1.141.0
 		 * @private
 		 * @ui5-restricted sap.ui.fl
 		 *

package/src/sap/ui/fl/initial/_internal/changeHandlers/ChangeHandlerStorage.js

@@ -23,7 +23,7 @@ sap.ui.define([
 	 * @alias sap.ui.fl.registry.ChangeHandlerStorage
 	 *
 	 * @author SAP SE
-	 * @version 1.139.0
+	 * @version 1.141.0
 	 * @private
 	 * @ui5-restricted sap.ui.fl
 	 *
@@ -135,10 +135,17 @@ sap.ui.define([
 		const sSkipNext = "ChangeHandlerStorage.registerChangeHandlersForControl.skip_next_then";
 
 		if (typeof mChangeHandlers === "string") {
-			oPromise = requireAsync(`${mChangeHandlers}.flexibility`)
-			.catch(function(oError) {
-				Log.error(`Flexibility change handler registration failed.\nControlType: ${sControlType}\n${oError.message}`);
-				return Promise.resolve(sSkipNext); // continue without a registration
+			oPromise = new Promise((resolve) => {
+				// TODO: The setTimeout is added to circumvent dependency issues caused by synchronous module loading.
+				// This shall be removed once sync loading is not used anymore in UI5. #todos10
+				setTimeout(() => {
+					requireAsync(`${mChangeHandlers}.flexibility`)
+					.then(resolve)
+					.catch(function(oError) {
+						Log.error(`Flexibility change handler registration failed.\nControlType: ${sControlType}\n${oError.message}`);
+						resolve(sSkipNext); // continue without a registration
+					});
+				}, 0);
 			});
 		}
 

package/src/sap/ui/fl/initial/_internal/connectors/Utils.js

@@ -62,7 +62,7 @@ sap.ui.define([
 	 *
 	 * @namespace sap.ui.fl.initial._internal.connectors.Utils
 	 * @since 1.70
-	 * @version 1.139.0
+	 * @version 1.141.0
 	 * @private
 	 * @ui5-restricted sap.ui.fl.initial._internal.connectors, sap.ui.fl.write._internal.connectors, sap.ui.fl.write._internal.transport
 	 */

package/src/sap/ui/fl/{apply → initial}/_internal/preprocessors/ControllerExtension.js

@@ -7,14 +7,18 @@
 sap.ui.define([
 	"sap/base/Log",
 	"sap/ui/core/Component",
-	"sap/ui/fl/apply/_internal/flexState/FlexState",
-	"sap/ui/fl/apply/_internal/flexState/ManifestUtils",
+	"sap/ui/fl/initial/_internal/Loader",
+	"sap/ui/fl/initial/_internal/ManifestUtils",
+	"sap/ui/fl/initial/_internal/StorageUtils",
+	"sap/ui/fl/requireAsync",
 	"sap/ui/fl/Utils"
 ], function(
 	Log,
 	Component,
-	FlexState,
+	Loader,
 	ManifestUtils,
+	StorageUtils,
+	requireAsync,
 	Utils
 ) {
 	"use strict";
@@ -26,7 +30,7 @@ sap.ui.define([
 	 * @class
 	 * @constructor
 	 * @author SAP SE
-	 * @version 1.139.0
+	 * @version 1.141.0
 	 * @since 1.27.0
 	 * @private
 	 * @ui5-restricted sap.ui.fl, sap.ui.core
@@ -102,7 +106,14 @@ sap.ui.define([
 			}
 			var sFlexReference = ManifestUtils.getFlexReferenceForControl(oAppComponent);
 
-			return FlexState.waitForInitialization(sFlexReference).then(() => {
+			return Loader.waitForInitialization(sFlexReference).then(async function() {
+				const oFlexData = Loader.getCachedFlexData(sFlexReference);
+				if (!StorageUtils.isStorageResponseFilled(oFlexData?.changes)) {
+					return [];
+				}
+
+				const FlexState = await requireAsync("sap/ui/fl/apply/_internal/flexState/FlexState");
+				await FlexState.waitForInitialization(sFlexReference);
 				const aFlexObjects = FlexState.getFlexObjectsDataSelector().get({reference: sFlexReference});
 				var aExtensionModules = aFlexObjects.filter(function(oChange) {
 					return isCodeExt(oChange) && isForController(sControllerName, oChange);