@openui5/sap.ui.core 1.115.0 → 1.116.0

package/.dtsgenrc

@@ -225,6 +225,24 @@
 						]
 					}
 				]
+			},
+			{
+				"name": "sap.ui.test.Opa",
+				"properties": [
+					{
+						"name": "and",
+						"type": "Omit<this, \"and\">"
+					}
+				]
+			},
+			{
+				"name": "sap.ui.test.Opa5",
+				"properties": [
+					{
+						"name": "and",
+						"type": "Omit<this, \"and\">"
+					}
+				]
 			}
 		]
 	}

package/.eslintrc.json

@@ -138,6 +138,17 @@
 			"parserOptions": {
 				"ecmaVersion": 6
 			}
+		},
+		{
+			"files": [
+				"src/ui5loader.js"
+			],
+			"env": {
+				"es2022": true
+			},
+			"parserOptions": {
+				"ecmaVersion": 2022
+			}
 		}
 	]
 }

package/.reuse/dep5

@@ -457,11 +457,6 @@ Comment: these files belong to: UI5 Web Components
 
 # Outside of Libraries:
 
-Files: src/testsuite-utils/src/main/resources/META-INF/less/less.js
-Copyright: 2009-2014, Alexis Sellier <self@cloudhead.net>
-License: Apache-2.0
-Comment: these files belong to: LESS
-
 Files: lib/jsdoc/ui5/plugin.js
 Copyright:
     2009-2023 SAP SE or an SAP affiliate company and OpenUI5 contributors

package/THIRDPARTY.txt

@@ -460,19 +460,13 @@ Contained in: src/sap.ui.webc.main/src/sap/ui/webc/main/thirdparty/*.*
 
 Outside of Libraries:
 
-Component: LESS, version: 1.6.3
-Copyright: 2009-2014, Alexis Sellier <self@cloudhead.net>
-License: Apache-2.0
-License Text: https://github.com/SAP/openui5/blob/master/LICENSES/Apache-2.0.txt
-Contained in: src/testsuite-utils/src/main/resources/META-INF/less/less.js
-
 Component: JSDoc 3, version: 3.6.7
 Copyright: 2011-present Michael Mathews micmath@gmail.com and the contributors to JSDoc
 License: Apache-2.0
 License Text: https://github.com/SAP/openui5/blob/master/LICENSES/Apache-2.0.txt
 Contained in: lib/jsdoc/ui5/plugin.js
 
-Component: SAP Theming Base Content, version: 11.3.0
+Component: SAP Theming Base Content, version: 11.4.2
 Copyright: SAP SE or an SAP affiliate company and Theming Base Content contributors
 License: Apache-2.0
 License Text: https://github.com/SAP/openui5/blob/master/LICENSES/Apache-2.0.txt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openui5/sap.ui.core",
-  "version": "1.115.0",
+  "version": "1.116.0",
   "description": "OpenUI5 Core Library sap.ui.core",
   "author": "SAP SE (https://www.sap.com)",
   "license": "Apache-2.0",

package/src/jquery.sap.global.js

@@ -208,7 +208,7 @@ sap.ui.define([
 	/**
 	 * Root Namespace for the jQuery plug-in provided by SAP SE.
 	 *
-	 * @version 1.115.0
+	 * @version 1.116.0
 	 * @namespace
 	 * @public
 	 * @static

package/src/jquery.sap.properties.js

@@ -67,7 +67,7 @@ sap.ui.define(['jquery.sap.global', 'sap/base/util/Properties'],
 	 * {@link #setProperty} to store or change a value for a key and {@link #getKeys}
 	 * can be used to retrieve an array of all keys that are currently stored in the collection.
 	 *
-	 * @version 1.115.0
+	 * @version 1.116.0
 	 * @since 0.9.0
 	 * @name jQuery.sap.util.Properties
 	 * @public

package/src/jquery.sap.resources.js

@@ -99,7 +99,7 @@ sap.ui.define([
 	 * Exception: Fallback for "zh_HK" is "zh_TW" before zh.
 	 *
 	 * @author SAP SE
-	 * @version 1.115.0
+	 * @version 1.116.0
 	 * @since 0.9.0
 	 * @name jQuery.sap.util.ResourceBundle
 	 * @public

package/src/jquery.sap.script.js

@@ -267,7 +267,7 @@ sap.ui.define([
 	 * Use {@link jQuery.sap.getUriParameters} to create an instance of jQuery.sap.util.UriParameters.
 	 *
 	 * @author SAP SE
-	 * @version 1.115.0
+	 * @version 1.116.0
 	 * @since 0.9.0
 	 * @name jQuery.sap.util.UriParameters
 	 * @public

package/src/jquery.sap.sjax.js

@@ -54,6 +54,8 @@ sap.ui.define(['jquery.sap.global'],
 	 */
 	jQuery.sap.sjax = function sjax(oOrigSettings) {
 
+		var oResult;
+
 		var s = jQuery.extend(true, {}, jQuery.sap.sjaxSettings, oOrigSettings,
 
 			// the following settings are enforced as this is the rightmost object in the extend call
@@ -68,8 +70,6 @@ sap.ui.define(['jquery.sap.global'],
 				}
 			});
 
-		var oResult;
-
 		jQuery.ajax(s);
 
 		if (!s.complexResult) {

package/src/jquery.sap.storage.js

@@ -37,7 +37,7 @@ sap.ui.define([
 	 * @param {string} [sIdPrefix] Prefix used for the Ids. If not set a default prefix is used.
 	 * @returns {jQuery.sap.storage.Storage}
 	 *
-	 * @version 1.115.0
+	 * @version 1.116.0
 	 * @since 0.11.0
 	 * @namespace
 	 * @public
@@ -97,7 +97,7 @@ sap.ui.define([
 	 * should be deleted the method {@link #removeAll} should be used.
 	 *
 	 * @author SAP SE
-	 * @version 1.115.0
+	 * @version 1.116.0
 	 * @since 0.11.0
 	 * @public
 	 * @name jQuery.sap.storage.Storage
@@ -201,7 +201,7 @@ sap.ui.define([
 	 * Enumeration of the storage types supported by {@link jQuery.sap.storage.Storage}
 	 * @enum {string}
 	 * @public
-	 * @version 1.115.0
+	 * @version 1.116.0
 	 * @since 0.11.0
 	 */
 	jQuery.sap.storage.Type = Storage.Type;

package/src/sap/base/Event.js

@@ -0,0 +1,106 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2023 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+// Provides class sap.base.Event
+sap.ui.define(["sap/base/assert"],
+	function(assert) {
+	"use strict";
+
+	var EVENT_PARAMETERS_SYMBOL = Symbol("parameters");
+
+	/**
+	 *
+	 * @class Creates an event with the given <code>sType</code>, linked to the provided <code>oTarget</code> and enriched with the <code>oParameters</code>.
+	 *
+	 * @param {string} sType The type of the event
+	 * @param {sap.base.Eventing} oTarget Target of the event
+	 * @param {object} oParameters Parameters for this event. The parameters will be accessible as properties of the Event instance.
+	 *
+	 * @author SAP SE
+	 * @version 1.116.0
+	 * @alias module:sap/base/Event
+	 * @private
+	 * @ui5-restricted sap.ui.core
+	 */
+	var Event = function(sType, oTarget, oParameters) {
+		if (arguments.length > 0) {
+			/**
+			 *The type of the event
+			 * @type {string}
+			 * @private
+			 * @ui5-restricted sap.ui.core
+			 */
+			this.type = sType;
+			/**
+			 * The target of the event
+			 * @type {object}
+			 * @private
+			 * @ui5-restricted sap.ui.core
+			 */
+			this.target = oTarget;
+			/**
+			 * Stop propagation of the event.
+			 * @type {boolean}
+			 * @private
+			 * @ui5-restricted sap.ui.core
+			 */
+			this.bStopPropagation = false;
+			/**
+			 * Prevent the default action of this event.
+			 * @type {object}
+			 * @private
+			 * @ui5-restricted sap.ui.core
+			 */
+			this.bPreventDefault = false;
+
+			//copy & freeze parameters
+			for (var param in oParameters) {
+				this[param] = oParameters[param];
+				Object.defineProperty(this, param, { configurable: false, writable: false });
+			}
+			this[EVENT_PARAMETERS_SYMBOL] = oParameters;
+
+			Object.defineProperty(this, "type", { configurable: false, writable: false });
+			Object.defineProperty(this, "target", { configurable: false, writable: false });
+		}
+	};
+
+	/**
+	 * Prevent the default action of this event.
+	 *
+	 * <b>Note:</b> This function only has an effect if preventing the default action of the event is supported by the event source.
+	 *
+	 * @private
+	 * @ui5-restricted sap.ui.core
+	 */
+	Event.prototype.preventDefault = function() {
+		this.bPreventDefault = true;
+	};
+
+	/**
+	 * Stop propagation of the event.
+	 *
+	 * <b>Note:</b> This function only has an effect if the propagation of the event is supported by the event source.
+	 *
+	 * @private
+	 * @ui5-restricted sap.ui.core
+	 */
+	Event.prototype.stopPropagation = function() {
+		this.bStopPropagation = true;
+	};
+
+	/**
+	 * Returns the event parameters as map
+	 * @param {sap.base.Event} oEvent The event object to retrieve the parameters
+	 * @returns {object} Map of event parameters
+	 * @private
+	 * @ui5-restricted sap/base/i18n sap.ui.core
+	 */
+	Event.getParameters = function(oEvent) {
+		return oEvent[EVENT_PARAMETERS_SYMBOL];
+	};
+
+	return Event;
+});

package/src/sap/base/Eventing.js

@@ -0,0 +1,320 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2023 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
+// Provides mixin sap/base/Eventing
+sap.ui.define([
+	"sap/base/assert",
+	"sap/base/Event"
+], function(
+	assert,
+	Event
+) {
+	"use strict";
+
+	/**
+	 * Eventing mixin
+	 *
+	 * @author SAP SE
+	 * @version 1.116.0
+	 * @param {sap.base.Event} fnEventClass The Event class
+	 * @mixin module:sap/base/Eventing
+	 * @private
+	 * @ui5-restricted sap.ui.core sap/base/i18n sap/ui/base/EventProvider
+	 */
+	var Eventing = function(fnEventClass) {
+		this.fnEventClass = fnEventClass || Event;
+		this.attachEvent = attachEvent;
+		this.attachEventOnce = attachEventOnce;
+		this.detachEvent = detachEvent;
+		this.fireEvent = fireEvent;
+		this.hasListeners = hasListeners;
+		this.getEventingParent = getEventingParent;
+		if (this.destroy) {
+			var fnOrigDestroy = this.destroy;
+			this.destroy = function() {
+				fnOrigDestroy.apply(this, arguments);
+				destroy();
+			};
+		} else {
+			this.destroy = destroy;
+		}
+	};
+
+	/**
+	 * Attaches an event handler to the event with the given identifier.
+	 *
+	 * @param {string}
+	 * 		sType The type of the event to listen for
+	 * @param {function}
+	 * 		fnFunction The handler function to call when the event occurs. The event
+	 * 		object ({@link module:sap/base/Event}) is provided as first argument of the handler. Handlers must not change
+	 * 		the content of the event.
+ 	 * @param {object}
+	 * 		[oData] An object that will be passed to the handler along with the event object when the event is fired
+	 * @returns {this} Returns <code>this</code> to allow method chaining
+	 * @name module:sap/base/Eventing#attachEvent
+	 * @function
+	 * @public
+	 */
+	function attachEvent(sType, fnFunction, oData) {
+		this.mEventRegistry = this.mEventRegistry || {};
+		assert(typeof (sType) === "string" && sType, "Eventing.attachEvent: sType must be a non-empty string");
+		assert(typeof (fnFunction) === "function", "Eventing.attachEvent: fnFunction must be a function");
+
+		var aEventListeners = this.mEventRegistry[sType];
+		if ( !Array.isArray(aEventListeners) ) {
+			aEventListeners = this.mEventRegistry[sType] = [];
+		}
+
+		aEventListeners.push({fnFunction: fnFunction, oData: oData});
+
+		return this;
+	}
+
+	/**
+	 * Attaches an event handler, called one time only, to the event with the given identifier.
+	 *
+	 * When the event occurs, the handler function is called and the handler registration is automatically removed afterwards.
+	 *
+	 * @param {string}
+	 *            sType The type of the event to listen for
+	 * @param {function}
+	 *            fnFunction The handler function to call when the event occurs. The event
+	 *                       object ({@link module:sap/base/Event}) is provided as first argument of the handler. Handlers must not change
+	 *                       the content of the event.
+	 * @param {object}
+	 *            [oData] An object that will be passed to the handler along with the event object when the event is fired
+	 * @returns {this} Returns <code>this</code> to allow method chaining
+	 * @name module:sap/base/Eventing#attachEventOnce
+	 * @function
+	 * @public
+	 */
+	function attachEventOnce(sType, fnFunction, oData) {
+		var fnOnce = function() {
+			this.detachEvent(sType, fnOnce);
+			fnFunction.apply(this, arguments);  // needs to do the same resolution as in fireEvent
+		};
+		fnOnce.oOriginal = {
+			fnFunction: fnFunction,
+			oData: oData
+		};
+		this.attachEvent(sType, fnOnce, oData);
+		return this;
+	}
+
+	/**
+	 * Removes a previously attached event handler from the event with the given identifier.
+	 *
+	 * The passed parameters must match those used for registration with {@link #attachEvent} beforehand.
+	 *
+	 * @param {string}
+	 *            sType The type of the event to detach from
+	 * @param {function}
+	 *            fnFunction The handler function to detach from the event
+	 * @returns {this} Returns <code>this</code> to allow method chaining
+	 * @name module:sap/base/Eventing#detachEvent
+	 * @function
+	 * @public
+	 */
+	function detachEvent(sType, fnFunction) {
+		this.mEventRegistry = this.mEventRegistry || {};
+		assert(typeof (sType) === "string" && sType, "Eventing.detachEvent: sType must be a non-empty string" );
+		assert(typeof (fnFunction) === "function", "Eventing.detachEvent: fnFunction must be a function");
+
+		var aEventListeners = this.mEventRegistry[sType];
+		if ( !Array.isArray(aEventListeners) ) {
+			return this;
+		}
+
+		var oFound, oOriginal;
+
+		for (var i = 0, iL = aEventListeners.length; i < iL; i++) {
+			if (aEventListeners[i].fnFunction === fnFunction) {
+				oFound = aEventListeners[i];
+				aEventListeners.splice(i,1);
+				break;
+			}
+		}
+		// If no listener was found, look for original listeners of attachEventOnce
+		if (!oFound) {
+			for (var i = 0, iL = aEventListeners.length; i < iL; i++) {
+				oOriginal = aEventListeners[i].fnFunction.oOriginal;
+				if (oOriginal && oOriginal.fnFunction === fnFunction) {
+					oFound = oOriginal;
+					aEventListeners.splice(i,1);
+					break;
+				}
+			}
+		}
+		// If we just deleted the last registered EventHandler, remove the whole entry from our map.
+		if (aEventListeners.length == 0) {
+			delete this.mEventRegistry[sType];
+		}
+
+		return this;
+	}
+
+	/**
+	 * Fires an {@link module:sap/base/Event event} with the given settings and notifies all attached event handlers.
+	 *
+	 * @param {string}
+	 *            sType The type of the event to fire
+	 * @param {object}
+	 *            [oParameters] Parameters which should be carried by the event
+	 * @param {boolean}
+	 *            [bAllowPreventDefault] Defines whether function <code>preventDefault</code> is supported on the fired event
+	 * @param {boolean}
+	 *            [bEnableEventBubbling] Defines whether event bubbling is enabled on the fired event. Set to <code>true</code> the event is also forwarded to the parent(s)
+	 *                                   of the event provider ({@link #getEventingParent}) until the bubbling of the event is stopped or no parent is available anymore.
+	 * @return {this|boolean} Returns <code>this</code> to allow method chaining. When <code>preventDefault</code> is supported on the fired event
+	 *                                             the function returns <code>true</code> if the default action should be executed, <code>false</code> otherwise.
+	 * @name module:sap/base/Eventing#fireEvent
+	 * @function
+	 * @protected
+	 */
+	function fireEvent(sType, oParameters, bAllowPreventDefault, bEnableEventBubbling) {
+
+		// get optional parameters right
+		if (typeof oParameters === "boolean") {
+			bEnableEventBubbling = bAllowPreventDefault;
+			bAllowPreventDefault = oParameters;
+		}
+		/* eslint-disable consistent-this */
+		var oProvider = this,
+		/* eslint-enable consistent-this */
+			bPreventDefault = false,
+			aEventListeners, oEvent, i, iL, oInfo;
+
+		do {
+			oProvider.mEventRegistry = oProvider.mEventRegistry || {};
+			aEventListeners = oProvider.mEventRegistry[sType];
+
+			if ( Array.isArray(aEventListeners) ) {
+
+				// avoid issues with 'concurrent modification' (e.g. if an event listener unregisters itself).
+				aEventListeners = aEventListeners.slice();
+				oEvent = new oProvider.fnEventClass(sType, this, oParameters);
+
+				for (i = 0, iL = aEventListeners.length; i < iL; i++) {
+					oInfo = aEventListeners[i];
+					oInfo.fnFunction.call(oProvider, oEvent, oInfo.oData);
+				}
+
+				bEnableEventBubbling = bEnableEventBubbling && !oEvent.bCancelBubble;
+			}
+
+			oProvider = oProvider.getEventingParent();
+
+		} while (bEnableEventBubbling && oProvider);
+
+		if ( oEvent ) {
+			// remember 'prevent default' state before returning event to the pool
+			bPreventDefault = oEvent.bPreventDefault;
+		}
+
+		// return 'execute default' flag only when 'prevent default' has been enabled, otherwise return 'this' (for compatibility)
+		return bAllowPreventDefault ? !bPreventDefault : this;
+	}
+
+	/**
+	 * Returns whether there are any registered event handlers for the event with the given identifier.
+	 *
+	 * @param {string} sType The type of the event
+	 * @return {boolean} Whether there are any registered event handlers
+	 * @name module:sap/base/Eventing#hasListeners
+	 * @function
+	 * @protected
+	 */
+	function hasListeners(sType) {
+		return !!(this.mEventRegistry && this.mEventRegistry[sType]);
+	}
+
+	/**
+	 * Returns the list of events currently having listeners attached.
+	 *
+	 * Introduced for lightspeed support to ensure that only relevant events are attached to the LS-world.
+	 *
+	 * This is a static method to avoid the pollution of the Element/Control namespace.
+	 * As the callers are limited and known and for performance reasons the internal event registry
+	 * is returned. It contains more information than necessary, but needs no expensive conversion.
+	 *
+	 * @param {sap.base.Eventing} oEventing The event provider to get the registered events for
+	 * @return {object} the list of events currently having listeners attached
+	 * @name module:sap/base/Eventing.getEventList
+	 * @function
+	 * @private
+	 * @static
+	 */
+	Eventing.getEventList = function(oEventing) {
+		return oEventing.mEventRegistry || {};
+	};
+
+	/**
+	 * Checks whether the given event provider has the given listener registered for the given event.
+	 *
+	 * Returns true if function and listener object both match the corresponding parameters of
+	 * at least one listener registered for the named event.
+	 *
+	 * @param {sap.base.Eventing}
+	 *            oEventing The event provider to get the registered events for
+	 * @param {string}
+	 *            sType The type of the event to check listeners for
+	 * @param {function}
+	 *            fnFunction The handler function to check for
+	 * @return {boolean} Returns whether a listener with the same parameters exists
+	 * @name module:sap/base/Eventing.hasListener
+	 * @function
+	 * @private
+	 * @ui5-restricted sap/base, sap.ui.core
+	 */
+	Eventing.hasListener = function(oEventing, sType, fnFunction) {
+		assert(typeof (sType) === "string" && sType, "Eventing.hasListener: sType must be a non-empty string" );
+		assert(typeof (fnFunction) === "function", "Eventing.hasListener: fnFunction must be a function");
+
+		var aEventListeners = oEventing && oEventing.mEventRegistry[sType];
+		if ( aEventListeners ) {
+			for (var i = 0, iL = aEventListeners.length; i < iL; i++) {
+				if (aEventListeners[i].fnFunction === fnFunction) {
+					return true;
+				}
+			}
+		}
+
+		return false;
+	};
+
+	/**
+	 * Returns the parent in the Eventing hierarchy of this object.
+	 *
+	 * Per default this returns null, but if Eventing is used in objects, which are hierarchically
+	 * structured, this can be overwritten to make the object hierarchy visible to the Eventing and
+	 * enables the use of event bubbling within this object hierarchy.
+	 *
+	 * @return {sap.base.Eventing|null} The parent event provider
+	 * @name module:sap/base/Eventing#getEventingParent
+	 * @function
+	 * @protected
+	 */
+	function getEventingParent() {
+		return null;
+	}
+
+	/**
+	 * Cleans up the internal structures and removes all event handlers.
+	 *
+	 * The object must not be used anymore after destroy was called.
+	 *
+	 * @see sap.base.Object#destroy
+	 * @name module:sap/base/Eventing#destroy
+	 * @function
+	 * @public
+	 */
+	function destroy() {
+		this.mEventRegistry = {};
+	}
+
+	return Eventing;
+});

package/src/sap/base/config.js

@@ -16,7 +16,7 @@ sap.ui.define([
 	 * The base Configuration.
 	 *
 	 * @author SAP SE
-	 * @version 1.115.0
+	 * @version 1.116.0
 	 * @private
 	 * @alias module:sap/base/config
 	 * @namespace