@openui5/sap.ui.core 1.136.2 → 1.138.0

package/src/sap/ui/core/plugin/LessSupport.js

@@ -44,7 +44,7 @@
 			 *        feature - DO NOT USE IN PRODUCTIVE SCENARIOS!!
 			 *
 			 * @author Peter Muessig
-			 * @version 1.136.2
+			 * @version 1.138.0
 			 * @private
 			 * @alias sap.ui.core.plugin.LessSupport
 			 */

package/src/sap/ui/core/plugin/TemplatingSupport.js

@@ -21,7 +21,7 @@ sap.ui.define([
 	 * @public
 	 * @since 1.15.0
 	 * @deprecated since 1.56, use an {@link sap.ui.core.mvc.XMLView} or a {@link topic:e6bb33d076dc4f23be50c082c271b9f0 Typed View} instead
-	 * @version 1.136.2
+	 * @version 1.138.0
 	 * @alias sap.ui.core.plugin.TemplatingSupport
 	 */
 	var TemplatingSupport = function() {

package/src/sap/ui/core/postmessage/Bus.js

@@ -38,7 +38,7 @@ function (
 	 * @alias sap.ui.core.postmessage.Bus
 	 * @author SAP SE
 	 * @since 1.56.0
-	 * @version 1.136.2
+	 * @version 1.138.0
 	 * @private
 	 * @ui5-restricted sap.ui.core.support, sap.ui.support, sap.ui.rta
 	 */

package/src/sap/ui/core/postmessage/confirmationDialog.js

@@ -13,7 +13,7 @@ sap.ui.define(["sap/ui/core/Lib"], function(Library) {
 	 *
 	 * @author SAP SE
 	 * @since 1.56.0
-	 * @version 1.136.2
+	 * @version 1.138.0
 	 *
 	 * @function
 	 * @param {string} sMessage - Dialog message

package/src/sap/ui/core/routing/Route.js

@@ -6,17 +6,28 @@
 
 
 sap.ui.define([
-	'sap/ui/base/EventProvider',
-	'sap/ui/core/routing/Target',
-	'sap/ui/core/routing/async/Route',
-	'sap/ui/core/routing/sync/Route',
-	'sap/ui/core/Component',
-	"sap/base/future",
+	"sap/base/Log",
 	"sap/base/assert",
-	"sap/base/util/deepExtend"
+	"sap/base/future",
+	"sap/base/util/deepExtend",
+	"sap/base/util/extend",
+	"sap/ui/base/EventProvider",
+	"sap/ui/core/Component",
+	"sap/ui/core/routing/Target",
+	"sap/ui/core/routing/sync/Route"
 ],
-	function(EventProvider, Target, asyncRoute, syncRoute, Component, future, assert, deepExtend) {
-	"use strict";
+	function(
+		Log,
+		assert,
+		future,
+		deepExtend,
+		extend,
+		EventProvider,
+		Component,
+		Target,
+		SyncRoute
+	) {
+		"use strict";
 
 		/**
 		 * Configuration object for a route
@@ -124,12 +135,14 @@ sap.ui.define([
 					aSubRoutes,
 					sRouteName,
 					oSubRouteConfig,
-					RouteStub,
+					/** @ui5-transform-hint replace-local true */
 					async = oRouter._isAsync();
 
-				RouteStub = async ? asyncRoute : syncRoute;
-				for (var fn in RouteStub) {
-					this[fn] = RouteStub[fn];
+
+				if (!async) {
+					for (const fn in SyncRoute) {
+						this[fn] = SyncRoute[fn];
+					}
 				}
 
 				if (!Array.isArray(vRoute)) {
@@ -693,6 +706,177 @@ sap.ui.define([
 			 */
 			getPatternArguments : function(sHash) {
 				return this._aRoutes[0].extrapolate(sHash);
+			},
+
+
+			/**
+			 * Executes the route matched logic
+			 *
+			 * @param {object} oArguments The arguments of the event
+			 * @param {Promise} oSequencePromise Promise chain for resolution in the correct order
+			 * @param {sap.ui.core.routing.Route} oNestingChild The nesting route
+			 * @returns {Promise} resolves with {name: *, view: *, control: *}
+			 * @private
+			 */
+			_routeMatched : function(oArguments, oSequencePromise, oNestingChild) {
+
+				var oRouter = this._oRouter,
+					oTarget,
+					oTargets,
+					oConfig,
+					oEventData,
+					oView = null,
+					oTargetControl = null,
+					bInitial,
+					oTargetData,
+					oCurrentPromise,
+					aAlignedTargets,
+					bRepeated = (oRouter._oMatchedRoute === this);
+
+				oRouter._sRouteInProgress = null;
+				oRouter._stopWaitingTitleChangedFromChild();
+
+				if (oRouter._oMatchedRoute) {
+					// clear the dynamicTarget of the previous matched route
+					delete oRouter._oMatchedRoute._oConfig.dynamicTarget;
+				}
+
+				oRouter._oMatchedRoute = this;
+				oRouter._bMatchingProcessStarted = true;
+
+				oConfig = extend({}, oRouter._oConfig, this._oConfig);
+
+				oTargets = oRouter.getTargets();
+				var sTitleName;
+				if (oTargets) {
+					sTitleName = oTargets._getTitleTargetName(oConfig.target, oConfig.titleTarget);
+					if (sTitleName && oRouter._oPreviousTitleChangedRoute !== this) {
+						oRouter._bFireTitleChanged = true;
+						if ((oRouter._oOwner && oRouter._oOwner._bRoutingPropagateTitle)) {
+							var oParentComponent = Component.getOwnerComponentFor(oRouter._oOwner);
+							var oParentRouter = oParentComponent && oParentComponent.getRouter();
+							if (oParentRouter) {
+								oParentRouter._waitForTitleChangedOn(oRouter);
+							}
+						}
+					} else {
+						oRouter._bFireTitleChanged = false;
+					}
+
+					if (this._oConfig.target) {
+						aAlignedTargets = oTargets._alignTargetsInfo(this._oConfig.target);
+						aAlignedTargets.forEach(function(oTarget){
+							oTarget.propagateTitle = oTarget.hasOwnProperty("propagateTitle") ? oTarget.propagateTitle : oRouter._oConfig.propagateTitle;
+							oTarget.routeRelevant = true;
+							oTarget.repeatedRoute = bRepeated;
+						});
+					}
+				} else {
+					aAlignedTargets = this._oConfig.target;
+				}
+
+				if (!oSequencePromise || oSequencePromise === true) {
+					bInitial = true;
+					oSequencePromise = Promise.resolve();
+				}
+
+				// Recursively fire matched event and display views of this routes parents
+				if (this._oParent) {
+					oSequencePromise = this._oParent._routeMatched(oArguments, oSequencePromise);
+				} else if (this._oNestingParent) {
+					// pass child for setting the flag in event parameter of parent
+					this._oNestingParent._routeMatched(oArguments, oSequencePromise, this);
+				}
+
+
+				// make a copy of arguments and forward route config to target
+				oTargetData = Object.assign({}, oArguments);
+				oTargetData.routeConfig = oConfig;
+
+				oEventData = {
+					name: oConfig.name,
+					arguments: oArguments,
+					config : oConfig
+				};
+
+				if (oNestingChild) {
+					// setting the event parameter of nesting child
+					oEventData.nestedRoute = oNestingChild;
+				}
+
+				// fire the beforeMatched and beforeRouteMathced events
+				this.fireBeforeMatched(oEventData);
+				oRouter.fireBeforeRouteMatched(oEventData);
+
+				// Route is defined without target in the config - use the internally created target to place the view
+				if (this._oTarget) {
+					oTarget = this._oTarget;
+					// update the targets config so defaults are taken into account - since targets cannot be added in runtime they don't merge configs like routes do
+					oTarget._updateOptions(this._convertToTargetOptions(oConfig));
+
+					oSequencePromise = oTarget._place(oSequencePromise, { legacy: true });
+
+					// this is for sap.m.routing.Router to chain the promise to the navigation promise in TargetHandler
+					if (this._oRouter._oTargetHandler && this._oRouter._oTargetHandler._chainNavigation) {
+						oCurrentPromise = oSequencePromise;
+						oSequencePromise = this._oRouter._oTargetHandler._chainNavigation(function() {
+							return oCurrentPromise;
+						});
+					}
+				} else {
+					oSequencePromise = oRouter._oTargets._display(aAlignedTargets, oTargetData, this._oConfig.titleTarget, oSequencePromise);
+				}
+
+				return oSequencePromise.then(function(oResult) {
+					oRouter._bMatchingProcessStarted = false;
+					var aResult, aViews, aControls;
+
+					// The legacy config uses single target to display which makes the promise resolve with an object
+					// However, the new config uses targets to display which makes the promise resolve with an array
+					// Both cases need to be handled here
+					if (Array.isArray(oResult)) {
+						aResult = oResult;
+						oResult = aResult[0];
+					}
+
+					oResult = oResult || {};
+
+					oView = oResult.view;
+					oTargetControl = oResult.control;
+
+					// Extend the event data with view and targetControl
+					oEventData.view = oView;
+					oEventData.targetControl = oTargetControl;
+
+					if (aResult) {
+						aViews = [];
+						aControls = [];
+
+						aResult.forEach(function(oResult) {
+							aViews.push(oResult.view);
+							aControls.push(oResult.control);
+						});
+
+						oEventData.views = aViews;
+						oEventData.targetControls = aControls;
+					}
+
+					if (oConfig.callback) {
+						//Targets don't pass TargetControl and view since there might be multiple
+						oConfig.callback(this, oArguments, oConfig, oTargetControl, oView);
+					}
+
+					this.fireEvent("matched", oEventData);
+					oRouter.fireRouteMatched(oEventData);
+					// skip this event in the recursion
+					if (bInitial) {
+						Log.info("The route named '" + oConfig.name + "' did match with its pattern", this);
+						this.fireEvent("patternMatched", oEventData);
+						oRouter.fireRoutePatternMatched(oEventData);
+					}
+
+					return oResult;
+				}.bind(this));
 			}
 		});
 

package/src/sap/ui/core/routing/Router.js

@@ -219,19 +219,21 @@ sap.ui.define([
 		 * </pre>
 		 * @public
 		 * @alias sap.ui.core.routing.Router
+		 * @ui5-transform-hint replace-param oConfig.async true
+		 * @ui5-transform-hint replace-param oConfig._async true
 		 */
 		var Router = EventProvider.extend("sap.ui.core.routing.Router", /** @lends sap.ui.core.routing.Router.prototype */ {
 
 			constructor : function(oRoutes, oConfig, oOwner, oTargetsConfig, oRouterHashChanger) {
 				EventProvider.apply(this);
 
-				this._oConfig = oConfig || {};
+				oConfig = oConfig || {};
 				this._oRouter = crossroads.create();
 				this._oRouter.ignoreState = true;
 				this._oRoutes = {};
 				this._oOwner = oOwner;
 
-				this._oConfig.router = this;
+				oConfig.router = this;
 
 				// temporarily: for checking the url param
 				function checkUrl() {
@@ -242,16 +244,17 @@ sap.ui.define([
 					return false;
 				}
 
-				// set the default view loading mode to sync for compatibility reasons
-				this._oConfig._async = this._oConfig.async;
-				if (this._oConfig._async === undefined) {
+				oConfig._async = oConfig.async;
+				if (oConfig._async === undefined) {
 					// temporarily: set the default value depending on the url parameter "sap-ui-xx-asyncRouting"
-					this._oConfig._async = checkUrl();
+					oConfig._async = checkUrl();
 				}
 
+				this._oConfig = oConfig;
+
 				this._oViews = new Views({
 					component : oOwner,
-					async : this._oConfig._async
+					async : oConfig._async
 				});
 
 				if (oTargetsConfig) {
@@ -881,6 +884,9 @@ sap.ui.define([
 				}
 
 				if (oComponentTargetInfo && !isEmptyObject(oComponentTargetInfo)) {
+					/**
+					 * @deprecated
+					 */
 					if (!this._oConfig._async) {
 						Log.error("navTo with component target info is only supported with async router", this);
 						return this;
@@ -1500,7 +1506,9 @@ sap.ui.define([
 				}
 
 				if (bImmediateFire) {
-					if (this._bMatchingProcessStarted && this._isAsync()) {
+					/** @ui5-transform-hint replace-local true */
+					const bAsync = this._isAsync();
+					if (this._bMatchingProcessStarted && bAsync) {
 						this.attachEventOnce("routeMatched", function(){
 							this.fireEvent(Router.M_EVENTS.TITLE_CHANGED, mParameters);
 						}, this);
@@ -1581,6 +1589,9 @@ sap.ui.define([
 				fnFireEvent();
 			},
 
+			/**
+			 * @deprecated
+			 */
 			_isAsync : function() {
 				return this._oConfig._async;
 			},

package/src/sap/ui/core/routing/RouterHashChanger.js

@@ -46,9 +46,18 @@ sap.ui.define([
 		return this.key ? (this.key + "-" + sKey) : sKey;
 	};
 
-	/*
-	 * @param {string} sKey the prefix for the sub RouterHashChanger
-	 * @return {sap.ui.core.routing.RouterHashChanger} the sub RouterHashChanger
+	/**
+	 * Returns a managed instance of {@link sap.ui.core.routing.RouterHashChanger} associated with the current instance.
+	 *
+	 * This sub-instance handles a specific part of the URL hash. When the sub-instance modifies the hash,
+	 * it notifies the parent instance, which then updates the browser’s hash accordingly.
+	 * Likewise, when the relevant part of the hash changes externally, the parent instance notifies the sub-instance.
+	 *
+	 * The provided <code>sKey</code> is used as an identifier for caching the sub-instance.
+	 * If this method is called again with the same key, the previously created instance is returned.
+	 *
+	 * @param {string} sKey A unique key used as the prefix for the sub RouterHashChanger.
+	 * @returns {sap.ui.core.routing.RouterHashChanger} The corresponding sub RouterHashChanger instance.
 	 * @protected
 	 */
 	RouterHashChanger.prototype.createSubHashChanger = function(sKey) {