@openui5/sap.ui.core 1.117.1 → 1.119.0

package/src/sap/ui/core/Messaging.js

@@ -0,0 +1,471 @@
+/*!
+ * 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/base/util/deepEqual",
+	"sap/base/util/merge",
+	"sap/ui/core/message/ControlMessageProcessor",
+	"sap/ui/core/message/Message",
+	"sap/ui/core/message/MessageType",
+	"sap/ui/core/message/MessageProcessor",
+	"sap/ui/model/message/MessageModel"
+], (
+	Log,
+	deepEqual,
+	merge,
+	ControlMessageProcessor,
+	Message,
+	MessageType,
+	MessageProcessor,
+	MessageModel
+) => {
+	"use strict";
+
+	var oMessageModel;
+	var mRegisteredProcessors = {};
+	var mAllMessages = {};
+	var oControlMessageProcessor;
+
+	/**
+	 * Messaging provides a central place for managing <code>sap.ui.core.message.Messages</code>.
+	 *
+	 * @namespace
+	 * @alias module:sap/ui/core/Messaging
+	 * @public
+	 * @since 1.118.0
+	 *
+	 */
+	const Messaging = {
+		/**
+		 * Add messages to Messaging
+		 *
+		 * @param {sap.ui.core.message.Message|sap.ui.core.message.Message[]} vMessages Array of sap.ui.core.message.Message or single sap.ui.core.message.Message
+		 * @public
+		 */
+		addMessages: function(vMessages) {
+			var oMessage = vMessages,
+				mProcessorsNeedsUpdate = _getAffectedProcessors(vMessages);
+
+			if (!vMessages) {
+				return;
+			} else if (Array.isArray(vMessages)) {
+				for (var i = 0; i < vMessages.length; i++) {
+					oMessage = vMessages[i];
+					_importMessage(oMessage);
+				}
+			} else {
+				_importMessage(vMessages);
+			}
+			_updateMessageModel(mProcessorsNeedsUpdate);
+		},
+
+		/**
+		 * Remove given Messages
+		 *
+		 * @param {sap.ui.core.message.Message|sap.ui.core.message.Message[]} vMessages - The message(s) to be removed.
+		 * @public
+		 */
+		removeMessages: function(vMessages) {
+			// Do not expose bOnlyValidationMessages to public API
+			_removeMessages.apply(Messaging, arguments);
+		},
+
+		/**
+		 * Remove all messages
+		 * @public
+		 */
+		removeAllMessages: function() {
+			var mProcessorsNeedsUpdate = {};
+
+			for (var sProcessorId in mAllMessages) {
+				//use the first Message/Message array to get the processor for the update
+				var sFirstKey = Object.keys(mAllMessages[sProcessorId])[0];
+				var vMessages = mAllMessages[sProcessorId][sFirstKey];
+				Object.assign(mProcessorsNeedsUpdate, _getAffectedProcessors(vMessages));
+			}
+			mAllMessages = {};
+			_updateMessageModel(mProcessorsNeedsUpdate);
+		},
+
+		/**
+		 * Update Messages by providing two arrays of old and new messages.
+		 *
+		 * The old ones will be removed, the new ones will be added.
+		 *
+		 * @param {Array<sap.ui.core.message.Message>} aOldMessages Array of old messages to be removed
+		 * @param {Array<sap.ui.core.message.Message>} aNewMessages Array of new messages to be added
+		 * @public
+		 */
+		updateMessages: function(aOldMessages, aNewMessages) {
+			Messaging.removeMessages(aOldMessages);
+			Messaging.addMessages(aNewMessages);
+			var aAllMessages = [].concat(aOldMessages || [], aNewMessages || []);
+			var mProcessors = _getAffectedProcessors(aAllMessages);
+			for (var sProcessorId in mProcessors) {
+				mProcessors[sProcessorId].fireEvent("messageChange", {
+					newMessages: aNewMessages,
+					oldMessages: aOldMessages
+				});
+			}
+		},
+
+		/**
+		 * Register MessageProcessor
+		 *
+		 * @param {sap.ui.core.message.MessageProcessor} oProcessor The MessageProcessor
+		 * @public
+		 */
+		registerMessageProcessor: function(oProcessor) {
+			var sProcessorId = oProcessor.getId(),
+				mProcessorsNeedsUpdate = {};
+
+			if (!mRegisteredProcessors[sProcessorId]) {
+				mRegisteredProcessors[sProcessorId] = sProcessorId;
+				if (sProcessorId in mAllMessages) {
+					mProcessorsNeedsUpdate[sProcessorId] = oProcessor;
+					_pushMessages(mProcessorsNeedsUpdate);
+				}
+				if (!MessageProcessor._isRegistered) {
+					var Messaging = sap.ui.require("sap/ui/core/Messaging");
+					var fnDestroy = MessageProcessor.prototype.destroy;
+					MessageProcessor.prototype.destroy = function () {
+						fnDestroy.apply(this);
+						Messaging.unregisterMessageProcessor(this);
+					};
+					MessageProcessor._isRegistered = true;
+				}
+			}
+		},
+
+		/**
+		 * Deregister MessageProcessor
+		 *
+		 * @param {sap.ui.core.message.MessageProcessor} oProcessor The MessageProcessor
+		 * @public
+		 */
+		unregisterMessageProcessor: function(oProcessor) {
+			_removeMessagesByProcessor(oProcessor.getId());
+			delete mRegisteredProcessors[oProcessor.getId()];
+		},
+
+		/**
+		 * When using the databinding type system, the validation/parsing of a new property value could fail.
+		 * In this case, a validationError/parseError event is fired. These events bubble up to the core.
+		 * For registered ManagedObjects, the Messaging attaches to these events and creates a
+		 * <code>sap.ui.core.message.Message</code> (bHandleValidation=true) for each of these errors
+		 * and cancels the event bubbling.
+		 *
+		 * @param {sap.ui.base.ManagedObject} oObject The sap.ui.base.ManagedObject
+		 * @param {boolean} bHandleValidation Handle validationError/parseError events for this object. If set to true,
+		 * the Messaging creates a Message for each validation/parse error. The event bubbling is canceled in every case.
+		 * @public
+		 */
+		registerObject: function(oObject, bHandleValidation) {
+			if (!(oObject && oObject.isA && (oObject.isA(["sap.ui.base.ManagedObject", "sap.ui.core.Core"])))) {
+				Log.error("Messaging: " + oObject.toString() + " is not an instance of sap.ui.base.ManagedObject");
+			} else {
+				oObject.attachValidationSuccess(bHandleValidation, _handleSuccess);
+				oObject.attachValidationError(bHandleValidation, _handleError);
+				oObject.attachParseError(bHandleValidation, _handleError);
+				oObject.attachFormatError(bHandleValidation, _handleError);
+			}
+		},
+
+		/**
+		 * Unregister ManagedObject
+		 *
+		 * @param {sap.ui.base.ManagedObject} oObject The sap.ui.base.ManagedObject
+		 * @public
+		 */
+		unregisterObject: function(oObject) {
+			if (!(oObject && oObject.isA && oObject.isA("sap.ui.base.ManagedObject"))) {
+				Log.error("Messaging: " + oObject.toString() + " is not an instance of sap.ui.base.ManagedObject");
+			} else {
+				oObject.detachValidationSuccess(_handleSuccess);
+				oObject.detachValidationError(_handleError);
+				oObject.detachParseError(_handleError);
+				oObject.detachFormatError(_handleError);
+			}
+		},
+
+		/**
+		 * Get the MessageModel
+		 * @return {sap.ui.model.message.MessageModel} oMessageModel The Message Model
+		 * @public
+		 */
+		getMessageModel: function() {
+			if (!oMessageModel) {
+				oMessageModel = new MessageModel();
+				oMessageModel.setData([]);
+			}
+			return oMessageModel;
+		}
+	};
+
+	/**
+	 * handle validation/parse/format error
+	 *
+	 * @param {object} oEvent The Event object
+	 * @param {boolean} bHandleValidation Wether validation errors should be handled or not.
+	 * @private
+	 */
+	function _handleError(oEvent, bHandleValidation) {
+		if (!oControlMessageProcessor) {
+			oControlMessageProcessor = new ControlMessageProcessor();
+		}
+		if (bHandleValidation) {
+			var oElement = oEvent.getParameter("element");
+			var sProperty = oEvent.getParameter("property");
+			var sTarget = oElement.getId() + '/' + sProperty;
+			var sProcessorId = oControlMessageProcessor.getId();
+			var bTechnical = oEvent.sId === "formatError";
+			if (mAllMessages[sProcessorId] && mAllMessages[sProcessorId][sTarget]) {
+				_removeMessages(mAllMessages[sProcessorId][sTarget], true);
+			}
+			var oReference = {};
+			oReference[oElement.getId()] = {
+					properties:{},
+					fieldGroupIds: oElement.getFieldGroupIds ? oElement.getFieldGroupIds() : undefined
+			};
+			oReference[oElement.getId()].properties[sProperty] = true;
+			var oMessage = new Message({
+					type: MessageType.Error,
+					message: oEvent.getParameter("message"),
+					target: sTarget,
+					processor: oControlMessageProcessor,
+					technical: bTechnical,
+					references: oReference,
+					validation: true
+				});
+			Messaging.addMessages(oMessage);
+		}
+		oEvent.cancelBubble();
+	}
+
+	/**
+	 * handle validation success
+	 *
+	 * @param {object} oEvent The Event object
+	 * @param {boolean} bHandleValidation Wether validation success should be handled or not.
+	 * @private
+	 */
+	function _handleSuccess(oEvent, bHandleValidation) {
+		if (!oControlMessageProcessor) {
+			oControlMessageProcessor = new ControlMessageProcessor();
+		}
+		if (bHandleValidation) {
+			var oElement = oEvent.getParameter("element");
+			var sProperty = oEvent.getParameter("property");
+			var sTarget = oElement.getId() + '/' + sProperty;
+			var sProcessorId = oControlMessageProcessor.getId();
+
+			if (mAllMessages[sProcessorId] && mAllMessages[sProcessorId][sTarget]) {
+				_removeMessages(mAllMessages[sProcessorId][sTarget], true);
+			}
+		}
+		oEvent.cancelBubble();
+	}
+
+	/**
+	 * import message to internal map of messages
+	 * @param {sap.ui.core.message.Message} oMessage The Message to import
+	 * @private
+	 */
+	function _importMessage(oMessage) {
+		var oProcessor = oMessage.getMessageProcessor(),
+			sProcessorId = oProcessor && oProcessor.getId(),
+			aTargets = oMessage.getTargets();
+
+		if (!mAllMessages[sProcessorId]) {
+			mAllMessages[sProcessorId] = {};
+		}
+		if (!aTargets.length) { // unbound message => add it to undefined entry
+			aTargets = [undefined];
+		}
+		aTargets.forEach(function (sTarget) {
+			var aMessages = mAllMessages[sProcessorId][sTarget] ? mAllMessages[sProcessorId][sTarget] : [];
+			aMessages.push(oMessage);
+			mAllMessages[sProcessorId][sTarget] = aMessages;
+		});
+	}
+
+	/**
+	 * push messages to registered MessageProcessors
+	 * @param {Object<string,sap.ui.core.message.MessageProcessor>} mProcessors A map containing the affected processor IDs
+	 * @private
+	 */
+	function _pushMessages(mProcessors) {
+		var oProcessor, sId;
+		for (sId in mProcessors) {
+			oProcessor = mProcessors[sId];
+			var vMessages = mAllMessages[sId] ? mAllMessages[sId] : {};
+			_sortMessages(vMessages);
+			//push a copy
+			vMessages = Object.keys(vMessages).length === 0 ? null : merge({}, vMessages);
+			oProcessor.setMessages(vMessages);
+		}
+	}
+
+	/**
+	 * Sort messages by type as specified in {@link sap.ui.core.message.Message#compare}.
+	 *
+	 * @param {Object<string,sap.ui.core.message.Message[]>|sap.ui.core.message.Message[]} vMessages
+	 *   Map or array of Messages to be sorted (in order of severity) by their type property
+	 * @private
+	 */
+	function _sortMessages(vMessages) {
+		var sTarget, aMessages;
+		if (Array.isArray(vMessages)) {
+			vMessages = { "ignored": vMessages };
+		}
+
+		for (sTarget in vMessages) {
+			aMessages = vMessages[sTarget];
+			if (aMessages.length > 1) {
+				aMessages.sort(Message.compare);
+			}
+		}
+	}
+
+	/**
+	 * update MessageModel
+	 * @param {Object<string,sap.ui.core.message.MessageProcessor>} mProcessors A map containing the affected processor IDs
+	 * @private
+	 */
+	function _updateMessageModel(mProcessors) {
+		var mUpdatedMessages = new Map(),
+			sProcessorId,
+			oMessageModel = Messaging.getMessageModel(),
+			sTarget;
+
+		function setMessage(oMessage) {
+			mUpdatedMessages.set(oMessage, true);
+		}
+
+		for (sProcessorId in mAllMessages) {
+			for (sTarget in mAllMessages[sProcessorId]) {
+				mAllMessages[sProcessorId][sTarget].forEach(setMessage);
+			}
+		}
+		_pushMessages(mProcessors);
+		oMessageModel.setData(Array.from(mUpdatedMessages.keys()));
+	}
+
+	/**
+	 * Like sap.ui.core.Messaging#removeMessage but with an additional argument to only remove validation
+	 * messages.
+	 *
+	 * @param {sap.ui.core.message.Message|sap.ui.core.message.Message[]} vMessages - The message(s) to be removed.
+	 * @param {boolean} bOnlyValidationMessages - If set to true only messages that have been added due to validation
+	 *        errors are removed.
+	 * @private
+	 */
+	function _removeMessages(vMessages, bOnlyValidationMessages) {
+		var mProcessors = _getAffectedProcessors(vMessages);
+
+		if (!vMessages || (Array.isArray(vMessages) && vMessages.length == 0)) {
+			return;
+		} else if (Array.isArray(vMessages)) {
+			// We need to work on a copy since the messages reference is changed by _removeMessage()
+			var aOriginalMessages = vMessages.slice(0);
+			for (var i = 0; i < aOriginalMessages.length; i++) {
+				if (!bOnlyValidationMessages || aOriginalMessages[i].validation) {
+					_removeMessage(aOriginalMessages[i]);
+				}
+			}
+		} else if (vMessages instanceof Message && (!bOnlyValidationMessages || vMessages.validation)){
+			_removeMessage(vMessages);
+		} else {
+			//map with target as key
+			for (var sTarget in vMessages) {
+				_removeMessages(vMessages[sTarget], bOnlyValidationMessages);
+			}
+		}
+		_updateMessageModel(mProcessors);
+	}
+
+	/**
+	 * remove Message
+	 *
+	 * @param {sap.ui.core.message.Message} oMessage The Message to remove
+	 * @private
+	 */
+	function _removeMessage(oMessage) {
+		var oProcessor = oMessage.getMessageProcessor(),
+			sProcessorId = oProcessor && oProcessor.getId(),
+			mProcessorMessages = mAllMessages[sProcessorId],
+			aTargets;
+
+		if (!mProcessorMessages) {
+			return;
+		}
+
+		aTargets = oMessage.getTargets();
+		if (!aTargets.length) { // unbound message => remove it from undefined entry
+			aTargets = [undefined];
+		}
+		aTargets.forEach(function (sTarget) {
+			var aMessages = mProcessorMessages[sTarget];
+
+			if (aMessages) {
+				for (var i = 0; i < aMessages.length; i++) {
+					var oMsg = aMessages[i];
+					if (deepEqual(oMsg, oMessage)) {
+						aMessages.splice(i,1);
+						--i; // Decrease counter as one element has been removed
+					}
+				}
+				// delete empty message array
+				if (mProcessorMessages[sTarget].length === 0) {
+					delete mProcessorMessages[sTarget];
+				}
+			}
+		});
+	}
+
+	/**
+	 * get affected processors
+	 * @param {sap.ui.core.message.Message|sap.ui.core.message.Message[]} vMessages Array of sap.ui.core.message.Message or single sap.ui.core.message.Message
+	 * @return {Object<string,sap.ui.core.message.MessageProcessor>} mProcessors A map containing the affected processor IDs
+	 * @private
+	 */
+	function _getAffectedProcessors(vMessages) {
+		var oProcessor,
+			sProcessorId,
+			mAffectedProcessors = {};
+
+		if (vMessages) {
+			if (!Array.isArray(vMessages)) {
+				vMessages = [vMessages];
+			}
+			vMessages.forEach(function(oMessage) {
+				oProcessor = oMessage.getMessageProcessor();
+				if (oProcessor) {
+					sProcessorId = oProcessor.getId();
+					mAffectedProcessors[sProcessorId] = oProcessor;
+					Messaging.registerMessageProcessor(oProcessor);
+				}
+			});
+		}
+		return mAffectedProcessors;
+	}
+
+	/**
+	 * Removes all Messages for the given Processor ID. This function
+	 * is used only during deregistration of a MessageProcessor. No
+	 * further 'pushMessages' needed.
+	 *
+	 * @param {string} sProcessorId The ID of a MessageProcessor
+	 * @private
+	 */
+	function _removeMessagesByProcessor(sProcessorId) {
+		delete mAllMessages[sProcessorId];
+		_updateMessageModel({});
+	}
+
+	return Messaging;
+});

package/src/sap/ui/core/Popup.js

@@ -958,7 +958,7 @@ sap.ui.define([
 
 		if (this._shouldGetFocusAfterOpen()) {
 			if (this._sInitialFocusId) {
-				oControl = Element.registry.get(this._sInitialFocusId);
+				oControl = Element.getElementById(this._sInitialFocusId);
 
 				if (oControl) {
 					oDomRefToFocus = oControl.getFocusDomRef();
@@ -1555,7 +1555,7 @@ sap.ui.define([
 		};
 
 		if (oPreviousFocus) {
-			var oFocusedControl = Element.registry.get(oPreviousFocus.sFocusId);
+			var oFocusedControl = Element.getElementById(oPreviousFocus.sFocusId);
 			if (oFocusedControl) {
 
 				// if an SAPUI5 control had been focused, just re-focus it
@@ -3293,7 +3293,7 @@ sap.ui.define([
 				// if the element is a control the focus should be called
 				// via the control
 				// especially if the control has an individual focus DOM-ref
-				var oControl = Element.registry.get(oFocusDomRef.id);
+				var oControl = Element.getElementById(oFocusDomRef.id);
 				if (oControl instanceof Control) {
 					Log.debug("Focus will be handled by " + oControl.getMetadata().getName(), "", sName);
 				} else {

package/src/sap/ui/core/RenderManager.js

@@ -18,10 +18,10 @@ sap.ui.define([
 	"sap/ui/performance/Measurement",
 	"sap/base/Log",
 	"sap/base/util/extend",
+	"./ControlBehavior",
 	"./InvisibleRenderer",
 	"./Patcher",
-	"./FocusHandler",
-	"sap/ui/core/Configuration"
+	"./FocusHandler"
 ], function(
 	LabelEnablement,
 	BaseObject,
@@ -35,15 +35,17 @@ sap.ui.define([
 	Measurement,
 	Log,
 	extend,
+	ControlBehavior,
 	InvisibleRenderer,
 	Patcher,
-	FocusHandler,
-	Configuration
+	FocusHandler
 ) {
 
 	"use strict";
 	/*global SVGElement*/
 
+	var Element;
+
 	var aCommonMethods = ["renderControl", "cleanupControlWithoutRendering", "accessibilityState", "icon"];
 
 	var aStrInterfaceMethods = ["write", "writeEscaped", "writeAcceleratorKey", "writeControlData", "writeElementData",
@@ -84,8 +86,8 @@ sap.ui.define([
 	 * Creates an instance of the RenderManager.
 	 *
 	 * Applications or controls must not call the <code>RenderManager</code> constructor on their own
-	 * but should use the {@link sap.ui.core.Core#createRenderManager sap.ui.getCore().createRenderManager()}
-	 * method to create an instance for their exclusive use.
+	 * but should rely on the re-rendering initiated by the framework lifecycle based on invalidation.
+	 * See {@link module:sap/ui/core/Element#invalidate} and {@link module:sap/ui/core/Control#invalidate}.
 	 *
 	 * @class A class that handles the rendering of controls.
 	 *
@@ -234,8 +236,9 @@ sap.ui.define([
 	 *
 	 * @extends Object
 	 * @author SAP SE
-	 * @version 1.117.1
+	 * @version 1.119.0
 	 * @alias sap.ui.core.RenderManager
+	 * @hideconstructor
 	 * @public
 	 */
 	function RenderManager() {
@@ -1608,7 +1611,7 @@ sap.ui.define([
 	 * @deprecated Since 1.92. Instead, use the {@link sap.ui.core.Core#getConfiguration} API.
 	 */
 	RenderManager.prototype.getConfiguration = function() {
-		return Configuration;
+		return sap.ui.require("sap/ui/core/Configuration");
 	};
 
 	/**
@@ -1743,7 +1746,7 @@ sap.ui.define([
 	 * @public
 	 */
 	RenderManager.prototype.accessibilityState = function(oElement, mProps) {
-		if (!Configuration.getAccessibility()) {
+		if (!ControlBehavior.isAccessibilityEnabled()) {
 			return this;
 		}
 
@@ -2295,6 +2298,8 @@ sap.ui.define([
 	RenderManager.preserveContent = function(oRootNode, bPreserveRoot, bPreserveNodesWithId, oControlBeforeRerender /* private */) {
 		assert(typeof oRootNode === "object" && oRootNode.ownerDocument == document, "oRootNode must be a DOM element");
 
+		Element = Element ? Element : sap.ui.require("sap/ui/core/Element");
+
 		aPreserveContentListeners.forEach(function(oListener) {
 			oListener.fn.call(oListener.context || RenderManager, {domNode : oRootNode});
 		});
@@ -2351,7 +2356,7 @@ sap.ui.define([
 				// before the re-rendering, UIArea moves all "to-be-preserved" nodes to the preserved area
 				// except the control dom nodes which must be moved to preserved area via control rendering cycle
 				if ( oControlBeforeRerender ) {
-					var oCandidateControl = sap.ui.getCore().byId(sPreserveMarker);
+					var oCandidateControl = Element.getElementById(sPreserveMarker);
 
 					// let the rendering cycle of the control handles the preserving
 					// but only when the control stack and the dom stack are in sync

package/src/sap/ui/core/Renderer.js

@@ -19,7 +19,7 @@ sap.ui.define([
 	 * @classdesc Base Class for a Renderer.
 	 *
 	 * @author SAP SE
-	 * @version 1.117.1
+	 * @version 1.119.0
 	 * @namespace
 	 * @public
 	 * @alias sap.ui.core.Renderer

package/src/sap/ui/core/Rendering.js

@@ -139,6 +139,7 @@ sap.ui.define([
 		 * @param {boolean} [bFirst=false]
 		 *   Whether the task should become the first one, not the last one
 		 * @private
+		 * @ui5-restricted sap.ui.model.odata.v4
 		 */
 		addPrerenderingTask: function (fnPrerenderingTask, bFirst) {
 			if (bFirst) {
@@ -197,14 +198,16 @@ sap.ui.define([
 		resume: function(sReason) {
 			Rendering.renderPendingUIUpdates(sReason, 0);
 		},
+
 		/**
 		 * Returns <code>true</code> if there are any pending rendering tasks or when
 		 * such rendering tasks are currently being executed.
 		 *
 		 * @return {boolean} true if there are pending (or executing) rendering tasks.
 		 * @private
+		 * @ui5-restricted sap.ui.core
 		 */
-		getUIDirty: function() {
+		isPending: function() {
 			return !!(_sRerenderTimer || _bRendering);
 		},
 
@@ -214,7 +217,6 @@ sap.ui.define([
 		 * @private
 		 * @function
 		 */
-
 		attachUIUpdated: function(fnFunction, oListener) {
 			_oEventProvider.attachEvent("UIUpdated", fnFunction, oListener);
 		},

package/src/sap/ui/core/ResizeHandler.js

@@ -36,7 +36,7 @@ sap.ui.define([
 	 * @alias sap.ui.core.ResizeHandler
 	 * @extends sap.ui.base.Object
 	 * @author SAP SE
-	 * @version 1.117.1
+	 * @version 1.119.0
 	 * @public
 	 */
 
@@ -52,9 +52,20 @@ sap.ui.define([
 
 			this.iIdCounter = 0;
 
-			this.fnDestroyHandler = this.destroy.bind(this);
-
-			jQuery(window).on("unload", this.fnDestroyHandler);
+			/**
+			 * The block below is not needed because it only did a cleanup
+			 * before the page was closed. This should not be necessary.
+			 * Nevertheless we leave the coding here and only deprecate it,
+			 * in order to keep the BFCache behavior stable.
+			 * Removing the 'unload' handler could potentially activate
+			 * the BFCache and cause a different behavior in browser versions
+			 * where the 'unload' handler is still supported.
+			 * Therefore we only removed the not needed cleanup coding
+			 * but still attach a noop to ensure this handler would still
+			 * invalidate the BFCache.
+			 * @deprecated as of 1.119
+			 */
+			window.addEventListener("unload", () => {});
 
 			ActivityDetection.attachActivate(initListener, this);
 
@@ -81,22 +92,6 @@ sap.ui.define([
 		}
 	}
 
-	/**
-	 * Destroy method of the Resize Handler.
-	 *
-	 * It unregisters the event handlers.
-	 *
-	 * @param {jQuery.Event} oEvent the event that initiated the destruction of the ResizeHandler
-	 * @private
-	 */
-	ResizeHandler.prototype.destroy = function(oEvent) {
-		ActivityDetection.detachActivate(initListener, this);
-		jQuery(window).off("unload", this.fnDestroyHandler);
-		this.aResizeListeners = [];
-		this.aSuspendedDomRefs = [];
-		clearListener.call(this);
-	};
-
 	/**
 	 * Attaches listener to resize event.
 	 *
@@ -212,9 +207,6 @@ sap.ui.define([
 	/**
 	 * Registers the given event handler for resize events on the given DOM element or control.
 	 *
-	 * <b>Note:</b> This function must not be used before the UI5 framework is initialized.
-	 * Please use the {@link sap.ui.core.Core#attachInit init event} of UI5 if you are not sure whether this is the case.
-	 *
 	 * The resize handler periodically checks the dimensions of the registered reference. Whenever it detects changes, an event is fired.
 	 * Be careful when changing dimensions within the event handler which might cause another resize event and so on.
 	 *