@openui5/sap.ui.core 1.117.0 → 1.118.0

package/src/sap/ui/qunit/utils/MemoryLeakCheck.js

@@ -6,8 +6,8 @@
 
 /*global QUnit*/
 
-sap.ui.define([ 'sap/ui/core/Element', 'sap/ui/core/Control', 'sap/ui/core/Core' /* provides sap.ui.getCore() */ ],
-		function(Element, Control) {
+sap.ui.define([ 'sap/ui/core/Element', 'sap/ui/core/Control', "sap/ui/qunit/utils/nextUIUpdate", 'sap/ui/core/Core' /* provides sap.ui.getCore() */ ],
+		function(Element, Control, nextUIUpdate) {
 	"use strict";
 
 	if ( typeof QUnit === "undefined" ) {
@@ -27,7 +27,7 @@ sap.ui.define([ 'sap/ui/core/Element', 'sap/ui/core/Control', 'sap/ui/core/Core'
 	 * @namespace
 	 *
 	 * @author SAP SE
-	 * @version 1.117.0
+	 * @version 1.118.0
 	 *
 	 * @public
 	 * @since 1.48.0
@@ -66,7 +66,7 @@ sap.ui.define([ 'sap/ui/core/Element', 'sap/ui/core/Control', 'sap/ui/core/Core'
 	// Has some special logic to ignore or work around problems where certain controls do not work standalone.
 	var _checkControl = function(sControlName, fnControlFactory, fnSomeAdditionalFunction, bControlCannotRender) {
 
-		QUnit.test("Control " + sControlName + " should not have any memory leaks", function(assert) {
+		QUnit.test("Control " + sControlName + " should not have any memory leaks", async function(assert) {
 			var oControl1 = fnControlFactory();
 
 			assert.ok(oControl1, "calling fnControlFactory() should return something (a control)");
@@ -90,7 +90,7 @@ sap.ui.define([ 'sap/ui/core/Element', 'sap/ui/core/Control', 'sap/ui/core/Core'
 			if (oControl1.placeAt && !bControlCannotRender) {
 				try {
 					oControl1.placeAt("qunit-fixture");
-					sap.ui.getCore().applyChanges();
+					await nextUIUpdate();
 
 				} catch (e) {
 					// control didn't say it has problems with rendering!
@@ -101,11 +101,11 @@ sap.ui.define([ 'sap/ui/core/Element', 'sap/ui/core/Control', 'sap/ui/core/Core'
 
 			if (fnSomeAdditionalFunction) {
 				fnSomeAdditionalFunction(oControl1);
-				sap.ui.getCore().applyChanges();
+				await nextUIUpdate();
 			}
 
 			oControl1.destroy();
-			sap.ui.getCore().applyChanges();
+			await nextUIUpdate();
 
 
 			// Render Control Instance 2 - any new controls leaked?
@@ -116,21 +116,20 @@ sap.ui.define([ 'sap/ui/core/Element', 'sap/ui/core/Control', 'sap/ui/core/Core'
 
 			if (oControl2.placeAt && !bControlCannotRender) {
 				oControl2.placeAt("qunit-fixture");
-				sap.ui.getCore().applyChanges();
+				await nextUIUpdate();
 
 				oControl2.rerender(); // just re-render again - this finds problems
-				sap.ui.getCore().applyChanges();
 			}
 
 			if (fnSomeAdditionalFunction) {
 				fnSomeAdditionalFunction(oControl2);
-				sap.ui.getCore().applyChanges();
+				await nextUIUpdate();
 			}
 
 			// check what's left after destruction
 
 			oControl2.destroy();
-			sap.ui.getCore().applyChanges();
+			await nextUIUpdate();
 			var mPostElements = getAllAliveControls();
 
 			// controls left over by second instance are real leaks that will grow proportionally to instance count => ERROR

package/src/sap/ui/qunit/utils/nextUIUpdate.js

@@ -0,0 +1,51 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2023 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+sap.ui.define([
+    "sap/base/Log",
+    "sap/ui/core/Rendering"
+], function(
+    Log,
+    Rendering
+) {
+	"use strict";
+
+    /**
+     * Return a Promise that resolves when the next Rendering is ready.
+     * If no rendering is sheduled it resolves immediately.
+     *
+     * @namespace
+     * @alias module:sap/ui/qunit/utils/nextUIUpdate
+     * @public
+     * @returns {Promise<undefined>} A promise resolving when the next UI update is finished
+     */
+    function nextUIUpdate() {
+        return new Promise(function(resolve) {
+            function isUpdated() {
+                Rendering.detachUIUpdated(isUpdated);
+                resolve();
+            }
+
+            if (Rendering.isPending()) {
+                Rendering.attachUIUpdated(isUpdated);
+            } else {
+                resolve();
+            }
+        });
+    }
+
+    /**
+     * Force a synchrounous rendering.
+     *
+     * @function
+     * @private
+     */
+    nextUIUpdate.runSync = function() {
+        Log.warning("Synchronous rendering forced: Please migrate to asynchronous rendering");
+        Rendering.renderPendingUIUpdates("forced sync rendering...");
+    };
+
+    return nextUIUpdate;
+});

package/src/sap/ui/test/ModuleTracking.js

@@ -0,0 +1,326 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2023 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
+(function () {
+	"use strict";
+	/*global QUnit */
+	/*eslint no-alert: 0, no-warning-comments: 0 */
+
+	const oScript = Array.from(document.getElementsByTagName("script"))
+		.find((oScript) => /ModuleTracking.js$/.test(oScript.getAttribute("src")));
+
+	function clone(o) {
+		return o && JSON.parse(JSON.stringify(o));
+	}
+
+	//**********************************************************************************************
+	// Code for tracking "Uncaught (in promise)" for sap.ui.base.SyncPromise inside QUnit tests
+	//**********************************************************************************************
+	var Log,
+		sClassName = "sap.ui.base.SyncPromise",
+		iNo = 0,
+		mUncaughtById = {},
+		mUncaughtPromise2Reason = new Map();
+
+	/**
+	 * Check for uncaught errors in sync promises and provide an appropriate report to the given
+	 * optional reporter.
+	 *
+	 * @param {function} [fnReporter]
+	 *   Optional reporter to receive a report
+	 */
+	function checkUncaught(fnReporter) {
+		var sId,
+			iLength = Object.keys(mUncaughtById).length
+				+ (mUncaughtPromise2Reason ? mUncaughtPromise2Reason.size : 0),
+			sMessage = "Uncaught (in promise): " + iLength + " times\n",
+			oPromise,
+			vReason,
+			oResult,
+			itValues;
+
+		if (iLength) {
+			for (sId in mUncaughtById) {
+				oPromise = mUncaughtById[sId];
+				if (oPromise.getResult() && oPromise.getResult().stack) {
+					sMessage += oPromise.getResult().stack;
+				} else {
+					sMessage += oPromise.getResult();
+				}
+				if (oPromise.$error.stack) {
+					sMessage += "\n>>> SyncPromise rejected with above reason...\n"
+						+ oPromise.$error.stack.split("\n").slice(2).join("\n"); // hide listener
+				}
+				sMessage += "\n\n";
+			}
+			mUncaughtById = {};
+
+			//TODO for (let vReason of mUncaughtPromise2Reason.values()) {...}
+			if (mUncaughtPromise2Reason && mUncaughtPromise2Reason.size) {
+				itValues = mUncaughtPromise2Reason.values();
+				for (;;) {
+					oResult = itValues.next();
+					if (oResult.done) {
+						break;
+					}
+					vReason = oResult.value;
+					sMessage += (vReason && vReason.stack || vReason) + "\n\n";
+				}
+				mUncaughtPromise2Reason.clear();
+			}
+
+			if (fnReporter) {
+				fnReporter(sMessage);
+			} else if (Log) {
+				Log.info(`Clearing ${iLength} uncaught promises`, sMessage, sClassName);
+			}
+		}
+	}
+
+	if (oScript.getAttribute("data-uncaught-in-promise") !== "true") {
+		/*
+		 * Listener for "unhandledrejection" events to keep track of "Uncaught (in promise)".
+		 */
+		window.addEventListener("unhandledrejection", function (oEvent) {
+			if (oEvent.reason && oEvent.reason.$uncaughtInPromise) { // ignore exceptional cases
+				return;
+			}
+
+			if (mUncaughtPromise2Reason) {
+				mUncaughtPromise2Reason.set(oEvent.promise, oEvent.reason);
+				oEvent.preventDefault(); // do not report on console
+			} else { // QUnit already done
+				alert("Uncaught (in promise) " + oEvent.reason);
+			}
+		});
+
+		/*
+		 * Listener for "rejectionhandled" events to keep track of "Uncaught (in promise)".
+		 */
+		window.addEventListener("rejectionhandled", function (oEvent) {
+			if (mUncaughtPromise2Reason) {
+				mUncaughtPromise2Reason.delete(oEvent.promise);
+			}
+		});
+	}
+
+	/**
+	 * Listener for sync promises which become (un)caught.
+	 *
+	 * @param {sap.ui.base.SyncPromise} oPromise
+	 *   A sync promise
+	 * @param {boolean} bCaught
+	 *   Tells whether the given sync promise became caught
+	 */
+	function listener(oPromise, bCaught) {
+		if (bCaught) {
+			delete mUncaughtById[oPromise.$id];
+			if (Log) {
+				Log.info(`Promise ${oPromise.$id} caught`,
+					Object.keys(mUncaughtById), sClassName);
+			}
+			return;
+		}
+
+		oPromise.$id = iNo++;
+		oPromise.$error = new Error();
+		mUncaughtById[oPromise.$id] = oPromise;
+		if (Log) {
+			Log.info(`Promise ${oPromise.$id} rejected with ${oPromise.getResult()}`,
+				Object.keys(mUncaughtById), sClassName);
+		}
+	}
+
+	//**********************************************************************************************
+	// Methods dealing with Istanbul
+	//**********************************************************************************************
+
+	// the initial coverage per module (identified by resource name), taken when QUnit starts
+	let mInitialCoverageByModule;
+	const mCoverageSnapshotByModule = {};
+	const bTestsFiltered = /(testId|filter)=/.test(window.location.search);
+
+	function filterCoverage() {
+		// only keep the coverage for the actually tested modules
+		if (window.__coverage__ && Object.keys(mCoverageSnapshotByModule ).length) {
+			window.__coverage__ = mCoverageSnapshotByModule;
+		}
+	}
+
+	function getResourceName(sModuleName) {
+		if (!window.__coverage__) {
+			return undefined;
+		}
+		const sPath = `${sModuleName.replace(/\./g, "/")}.js`;
+		return Object.keys(window.__coverage__)
+			.find((sResourceName) => sResourceName.endsWith(sPath));
+	}
+
+	function resetBranchCounts(oCurrent, oInitial) {
+		const oCurrentCounts = oCurrent.b;
+		const oInitialCounts = oInitial.b;
+		for (const [sKey, aInitialCounts] of Object.entries(oInitialCounts)) {
+			const aCurrentCounts = oCurrentCounts[sKey];
+			aInitialCounts.forEach((iCount, i) => { aCurrentCounts[i] = iCount; });
+		}
+	}
+
+	function resetCounts(oCurrent, oInitial, sList) {
+		const oCurrentCounts = oCurrent[sList];
+		const oInitialCounts = oInitial[sList];
+		for (const [sKey, iCount] of Object.entries(oInitialCounts)) {
+			oCurrentCounts[sKey] = iCount;
+		}
+	}
+
+	function resetModuleCoverage(sModuleName) {
+		const sResourceName = getResourceName(sModuleName);
+		if (sResourceName) {
+			// keep only coverage for the module loading
+			const oCurrent = window.__coverage__[sResourceName];
+			const oInitial = mInitialCoverageByModule[sResourceName];
+			resetBranchCounts(oCurrent, oInitial);
+			resetCounts(oCurrent, oInitial, "f");
+			resetCounts(oCurrent, oInitial, "s");
+		}
+	}
+
+	function saveInitialCoverage() {
+		// the coverage from the module loading
+		mInitialCoverageByModule = clone(window.__coverage__);
+	}
+
+	/**
+	 * Takes a snapshot and verify that all branches, statements and functions are covered.
+	 *
+	 * @param {string} sModuleName - The module name
+	 * @returns {boolean} Whether the coverage is bad
+	 */
+	function handleModuleCoverage(sModuleName) {
+		const sResourceName = getResourceName(sModuleName);
+		if (!sResourceName) {
+			return false;
+		}
+		const oCoverage = clone(window.__coverage__[sResourceName]);
+		mCoverageSnapshotByModule[sResourceName] = oCoverage;
+		if (bTestsFiltered) {
+			return false;
+		}
+		return Object.values(oCoverage.b).some((aCounts) => aCounts.some((iCount) => iCount === 0))
+			|| Object.values(oCoverage.f).some((iCount) => iCount === 0)
+			|| Object.values(oCoverage.s).some((iCount) => iCount === 0);
+	}
+
+	//**********************************************************************************************
+	// Intercept QUnit
+	// Each module shall only be covered when its own tests run. For this purpose we keep the
+	// initial module states. When a module is started, we revert its coverage to the initial state.
+	// When it's finished we take a snapshot. In the end we only keep the snapshots.
+	//**********************************************************************************************
+
+	const fnModule = QUnit.module.bind(QUnit);
+
+	/**
+	 * Wrapper for <code>QUnit.module</code> to check for uncaught errors in sync promises and
+	 * for 100% isolated test coverage.
+	 *
+	 * @param {string} sTitle
+	 *   The module's title
+	 * @param {object} [mHooks]
+	 *   Optional map of hooks, e.g. "beforeEach"
+	 */
+	function module(sTitle, mHooks) {
+		mHooks = mHooks || {};
+		const fnAfter = mHooks.after || function () {};
+		const fnAfterEach = mHooks.afterEach || function () {};
+		const fnBefore = mHooks.before || function () {};
+		const fnBeforeEach = mHooks.beforeEach || function () {};
+
+		mHooks.after = function (assert) {
+			if (!this.__ignoreIsolatedCoverage__ && handleModuleCoverage(sTitle)) {
+				assert.ok(false, `${sTitle}: Coverage below 100%`);
+			}
+
+			return fnAfter.apply(this, arguments);
+		};
+
+		mHooks.afterEach = function (assert) {
+			const fnCheckUncaught = checkUncaught.bind(null, assert.ok.bind(assert, false));
+
+			function error(oError) {
+				fnCheckUncaught();
+				throw oError;
+			}
+
+			function success(vResult) {
+				if (vResult && typeof vResult.then === "function") {
+					return vResult.then(success, error);
+				}
+				fnCheckUncaught();
+				return vResult;
+			}
+
+			try {
+				return success(fnAfterEach.apply(this, arguments));
+			} catch (oError) {
+				return error(oError);
+			}
+		};
+
+		mHooks.before = function () {
+			const oResult = fnBefore.apply(this, arguments);
+			if (!this.__ignoreIsolatedCoverage__) {
+				resetModuleCoverage(sTitle);
+			}
+			return oResult;
+		};
+
+		mHooks.beforeEach = function () {
+			checkUncaught(); // cleans up what happened before
+			return fnBeforeEach.apply(this, arguments);
+		};
+
+		fnModule(sTitle, mHooks);
+	}
+
+	if (QUnit.module !== module) {
+		QUnit.module = module;
+		sap.ui.require([
+			"sap/base/Log",
+			"sap/ui/base/SyncPromise"
+		], function (Log0, SyncPromise) {
+			if (Log0.isLoggable(Log0.Level.INFO, sClassName)) {
+				Log = Log0;
+			}
+			SyncPromise.listener = listener;
+		});
+
+		QUnit.begin(() => {
+			// allow easier module selection: larger list, one click selection
+			document.body.style.overflow = "scroll"; // always show scrollbar, avoid flickering
+			document.getElementById("qunit-modulefilter-dropdown-list").style.maxHeight = "none";
+
+			document.getElementById("qunit-modulefilter-dropdown")
+				.addEventListener("click", function (oMouseEvent) {
+					if (oMouseEvent.target.tagName === "LABEL"
+							&& oMouseEvent.target.innerText !== "All modules") {
+						setTimeout(function () {
+							// click on label instead of checkbox triggers "Apply" automatically
+							document.getElementById("qunit-modulefilter-actions").firstChild
+								.dispatchEvent(new MouseEvent("click"));
+						});
+					}
+				});
+
+			// remember which lines have been covered initially, at load time
+			saveInitialCoverage();
+		});
+
+		QUnit.done(() => {
+			filterCoverage();
+		});
+	}
+}());

package/src/sap/ui/test/TestUtils.js

@@ -11,8 +11,8 @@ sap.ui.define([
 	"sap/ui/base/SyncPromise",
 	"sap/ui/thirdparty/jquery",
 	"sap/ui/core/Lib",
-	"sap/ui/core/Core" // provides sap.ui.getCore()
-], function (Log, merge, UriParameters, SyncPromise, jQuery, Library) {
+	"sap/ui/core/Rendering"
+], function (Log, merge, UriParameters, SyncPromise, jQuery, Library, Rendering) {
 	"use strict";
 	/*global QUnit, sinon */
 	// Note: The dependency to Sinon.JS has been omitted deliberately. Most test files load it via
@@ -145,7 +145,7 @@ sap.ui.define([
 		awaitRendering : function () {
 			return new Promise(function (resolve) {
 				function check() {
-					if (sap.ui.getCore().getUIDirty()) {
+					if (Rendering.isPending()) {
 						setTimeout(check, 1);
 					} else {
 						resolve();
@@ -338,8 +338,9 @@ sap.ui.define([
 		 *    response(s) objects in the response property. If no match for a request was found in
 		 *    the normal fixture, the regular expressions are checked. The response object looks
 		 *    exactly the same as in the fixture and may additionally contain a method
-		 *    <code>buildResponse(aMatch, oResponse)</code> which gets passed the match object and
-		 *    the response to allow modification before sending.
+		 *    <code>buildResponse(aMatch, oResponse, oRequest)</code> which gets passed the match
+		 *    object, the response, and the request in order to allow modification of the response
+		 *   before sending.
 		 * @param {string} [sServiceUrl]
 		 *   The service URL which determines a prefix for all requests the fake server responds to;
 		 *   it responds with an error for requests not given in the fixture, except DELETE, MERGE,
@@ -586,7 +587,7 @@ sap.ui.define([
 					oResponse = aResponses[0];
 					if (typeof oResponse.buildResponse === "function") {
 						oResponse = merge({}, oResponse);
-						oResponse.buildResponse(oMatch.match, oResponse);
+						oResponse.buildResponse(oMatch.match, oResponse, oRequest);
 					}
 					if (oMatch.responses.length > 1) {
 						iAlternative = oMatch.responses.indexOf(oResponse);

package/src/sap/ui/test/autowaiter/_UIUpdatesWaiter.js

@@ -5,15 +5,16 @@
  */
 
 sap.ui.define([
+	"sap/ui/core/Rendering",
 	"./WaiterBase"
-], function (WaiterBase) {
+], function (Rendering, WaiterBase) {
 	"use strict";
 
 	var UIUpdatesWaiter = WaiterBase.extend("sap.ui.test.autowaiter._UIUpdatesWaiter", {
 		// ensure that timeouts set by control inner updates are not hooked into by _timeoutWaiter
 		// if an update is continuously made by the UI, at some point it will be ignored by this validation
 		hasPending: function () {
-			var bUIDirty = sap.ui.getCore().getUIDirty();
+			var bUIDirty = Rendering.isPending();
 			if (bUIDirty) {
 				this._oHasPendingLogger.debug("The UI needs rerendering");
 			}

package/src/sap/ui/test/generic/TestBase.js

@@ -26,7 +26,7 @@ sap.ui.define([
 	 * @extends sap.ui.base.Object
 	 * @abstract
 	 * @author SAP SE
-	 * @version 1.117.0
+	 * @version 1.118.0
 	 * @since 1.100
 	 */
 	return BaseObject.extend("sap.ui.test.generic.TestBase", {

package/src/sap/ui/test/selectors/_ControlSelectorGenerator.js

@@ -459,6 +459,7 @@
      /**
      * Iterate through all controls a a given level and attempt to generate a unique selector for each one.
      * stop the cycle as soon as one unique selector is found
+     * @param {object} oOptions Object with options
      * @param {Array} oOptions.siblings the children at a given tree level
      * @param {object} oOptions.options filter options
      * @param {number} oOptions.index index of the child for which to start the search
@@ -519,6 +520,7 @@
     /**
      * Filters valid selectors.
      * @param {object} vSelector a control selector or array of selectors
+     * @param {object} oOptions Object with options
      * @param {object} oOptions.validationRoot the subtree root. If not defined, the selector will be valid for the entire app.
      * @param {boolean} oOptions.multiple whether the selector can match multiple controls. False by default.
      * @returns {array} an array of valid selectors

package/src/sap/ui/test/selectors/_DropdownItem.js

@@ -23,6 +23,7 @@ sap.ui.define([
         /**
          * Generates control selector for sap.m.Select and sap.m.ComboBox items
          * @param {object} oControl the control for which to generate a selector
+         * @param {object} mSelectorParts Options object
          * @param {object} mSelectorParts.ancestor the control selector for the parent dropdown
          * @returns {object} a plain object representation of a control. Contains the dropdown ancestor selector, item controlType and item key
          * Undefined, if the control is not a dropdown

package/src/sap/ui/test/selectors/_TableRowItem.js

@@ -24,6 +24,7 @@ sap.ui.define([
 
         /**
          * @param {object} oControl the control for which to generate a selector
+         * @param {object} mSelectorParts Options object
          * @param {object} mSelectorParts.table unique selector for the control's table
          * @param {object} mSelectorParts.relative selector for the control that is unique in the row subtree
          * @returns {object} a plain object representation of a control. Contains unique selector within row, row binding path and table selector

package/src/sap/ui/util/Storage.js

@@ -277,7 +277,7 @@ sap.ui.define(["sap/base/assert"], function (assert) {
 	 *
 	 * @enum {string}
 	 * @public
-	 * @version 1.117.0
+	 * @version 1.118.0
 	 */
 	Storage.Type = {
 		/**

package/src/ui5loader-autoconfig.js

@@ -158,6 +158,7 @@
 		"sap/base/strings/_camelize"
 	], function (camelize) {
 		var oConfig;
+		var oWriteableConfig = Object.create(null);
 		var rAlias = /^(sapUiXx|sapUi|sap)((?:[A-Z0-9][a-z]*)+)$/; //for getter
 		var mFrozenProperties = Object.create(null);
 		var bFrozen = false;
@@ -173,9 +174,9 @@
 					var vFrozenValue = mFrozenProperties[sNormalizedKey];
 					if (!sNormalizedKey) {
 						ui5loader._.logger.error("Invalid configuration option '" + sKey + "' in global['sap-ui-config']!");
-					} else if (oConfig[sNormalizedKey]) {
+					} else if (Object.hasOwn(oConfig, sNormalizedKey)) {
 						ui5loader._.logger.error("Configuration option '" + sKey + "' was already set by '" + mOriginalGlobalParams[sNormalizedKey] + "' and will be ignored!");
-					} else if (vFrozenValue !== undefined && oGlobalConfig[sKey] !== vFrozenValue) {
+					} else if (Object.hasOwn(mFrozenProperties, sNormalizedKey) && oGlobalConfig[sKey] !== vFrozenValue) {
 						oConfig[sNormalizedKey] = vFrozenValue;
 						ui5loader._.logger.error("Configuration option '" + sNormalizedKey + "' was frozen and cannot be changed to " + oGlobalConfig[sKey] + "!");
 					} else {
@@ -195,12 +196,15 @@
 		}
 
 		function get(sKey, bFreeze) {
-			var vValue = oConfig[sKey];
-			if (vValue === undefined) {
+			if (Object.hasOwn(mFrozenProperties,sKey)) {
+				return mFrozenProperties[sKey];
+			}
+			var vValue = oWriteableConfig[sKey] || oConfig[sKey];
+			if (!Object.hasOwn(oConfig, sKey) && !Object.hasOwn(oWriteableConfig, sKey)) {
 				var vMatch = sKey.match(rAlias);
 				var sLowerCaseAlias = vMatch ? vMatch[1] + vMatch[2][0] + vMatch[2].slice(1).toLowerCase() : undefined;
 				if (sLowerCaseAlias) {
-					vValue = oConfig[sLowerCaseAlias];
+					vValue = oWriteableConfig[sLowerCaseAlias] || oConfig[sLowerCaseAlias];
 				}
 			}
 			if (bFreeze) {
@@ -210,10 +214,10 @@
 		}
 
 		function set(sKey, vValue) {
-			if (mFrozenProperties[sKey]) {
+			if (Object.hasOwn(mFrozenProperties, sKey) || bFrozen) {
 				ui5loader._.logger.error("Configuration option '" + sKey + "' was frozen and cannot be changed to " + vValue + "!");
 			} else {
-				oConfig[sKey] = vValue;
+				oWriteableConfig[sKey] = vValue;
 			}
 		}
 
@@ -247,7 +251,7 @@
 					var sNormalizedKey = camelize(sKey);
 					if (!sNormalizedKey) {
 						ui5loader._.logger.error("Invalid configuration option '" + sKey + "' in bootstrap!");
-					} else if (oConfig[sNormalizedKey]) {
+					} else if (Object.hasOwn(oConfig, sNormalizedKey)) {
 						ui5loader._.logger.error("Configuration option '" + sKey + "' already exists and will be ignored!");
 					} else {
 						oConfig[sNormalizedKey] = dataset[sKey];
@@ -289,7 +293,7 @@
 				var sNormalizedKey = camelize(key);
 				if (!sNormalizedKey) {
 					ui5loader._.logger.error("Invalid configuration option '" + key + "' in url!");
-				} else if (oConfig[sNormalizedKey]) {
+				} else if (Object.hasOwn(oConfig, sNormalizedKey)) {
 					ui5loader._.logger.error("Configuration option '" + key + "' was already set by '" + mOriginalUrlParams[sNormalizedKey] + "' and will be ignored!");
 				} else {
 					oConfig[sNormalizedKey] = value;
@@ -323,7 +327,7 @@
 			allMetaTags.forEach(function(tag) {
 				var sNormalizedKey = camelize(tag.name);
 				if (sNormalizedKey) {
-					if (oConfig[sNormalizedKey]) {
+					if (Object.hasOwn(oConfig, sNormalizedKey)) {
 						ui5loader._.logger.error("Configuration option '" + tag.name + "' was already set by '" + mOriginalTagNames[sNormalizedKey] + "' and will be ignored!");
 					} else {
 						oConfig[sNormalizedKey] = tag.content;

package/src/ui5loader.js

@@ -3102,7 +3102,7 @@
 	 * @param {string} [sModuleName] ID of the module in simplified resource name syntax.
 	 *        When omitted, the loader determines the ID from the request.
 	 * @param {string[]} [aDependencies] List of dependencies of the module
-	 * @param {function(...any):any|any} vFactory The module export value or a function that calculates that value
+	 * @param {function|any} vFactory The module export value or a function that calculates that value
 	 * @param {boolean} [bExport] Whether an export to global names is required - should be used by SAP-owned code only
 	 * @since 1.27.0
 	 * @public
@@ -3167,7 +3167,7 @@
 	 * Relative module names are not supported.
 	 *
 	 * @param {string|string[]} vDependencies Dependency (dependencies) to resolve
-	 * @param {function(...any)} [fnCallback] Callback function to execute after resolving an array of dependencies
+	 * @param {function} [fnCallback] Callback function to execute after resolving an array of dependencies
 	 * @param {function(Error)} [fnErrback] Callback function to execute if an error was detected while loading the
 	 *                      dependencies or executing the factory function. Note that due to browser restrictions
 	 *                      not all errors will be reported via this callback. In general, module loading is