@sap/open.fe 1.96.0 → 1.97.0

package/packages/sap.fe.core/src/sap/fe/core/formatters/TableFormatter-dbg.js

@@ -7,20 +7,43 @@ sap.ui.define(["sap/fe/core/formatters/TableFormatterTypes"], function (TableFor
 
   var MessageType = TableFormatterTypes.MessageType;
 
+  var getMessagetypeOrder = function (messageType) {
+    switch (messageType) {
+      case "Error":
+        return 4;
+
+      case "Warning":
+        return 3;
+
+      case "Information":
+        return 2;
+
+      case "None":
+        return 1;
+
+      default:
+        return -1;
+    }
+  };
   /**
    * rowHighlighting
    *
    * @param {object} this The context
-   * @param {string|number} CriticalityValue criticality value
-   * @param {number} messageLastUpdate Timestamp of the last message created,  It's defined as input value but it is not used in the body of the function
+   * @param {string|number} CriticalityValue The criticality value
+   * @param {number} messageLastUpdate Timestamp of the last message that was created. It's defined as an input value, but not used in the body of the function
    * It is used to refresh the formatting of the table each time a new message is updated
    * @returns {object} The value from the inner function
    */
+
+
   var rowHighlighting = function (criticalityValue, aFilteredMessages) {
+    var iHighestCriticalityValue = -1;
+
     if (aFilteredMessages) {
       var sCurrentContextPath = this.getBindingContext() ? this.getBindingContext().getPath() : undefined;
       aFilteredMessages.forEach(function (oMessage) {
-        if (oMessage.aTargets[0].indexOf(sCurrentContextPath) === 0) {
+        if (oMessage.aTargets[0].indexOf(sCurrentContextPath) === 0 && iHighestCriticalityValue < getMessagetypeOrder(oMessage.type)) {
+          iHighestCriticalityValue = getMessagetypeOrder(oMessage.type);
           criticalityValue = oMessage.type;
         }
       });
@@ -97,4 +120,4 @@ sap.ui.define(["sap/fe/core/formatters/TableFormatterTypes"], function (TableFor
 
   return tableFormatters;
 }, true);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIlRhYmxlRm9ybWF0dGVyLnRzIl0sIm5hbWVzIjpbImdldE1lc3NhZ2V0eXBlT3JkZXIiLCJtZXNzYWdlVHlwZSIsInJvd0hpZ2hsaWdodGluZyIsImNyaXRpY2FsaXR5VmFsdWUiLCJhRmlsdGVyZWRNZXNzYWdlcyIsImlIaWdoZXN0Q3JpdGljYWxpdHlWYWx1ZSIsInNDdXJyZW50Q29udGV4dFBhdGgiLCJnZXRCaW5kaW5nQ29udGV4dCIsImdldFBhdGgiLCJ1bmRlZmluZWQiLCJmb3JFYWNoIiwib01lc3NhZ2UiLCJhVGFyZ2V0cyIsImluZGV4T2YiLCJ0eXBlIiwiY3JpdGljYWxpdHlQcm9wZXJ0eSIsIk1lc3NhZ2VUeXBlIiwiRXJyb3IiLCJXYXJuaW5nIiwiU3VjY2VzcyIsIkluZm9ybWF0aW9uIiwiTm9uZSIsIl9fZnVuY3Rpb25OYW1lIiwibmF2aWdhdGVkUm93Iiwic0RlZXBlc3RQYXRoIiwidGFibGVGb3JtYXR0ZXJzIiwic05hbWUiLCJoYXNPd25Qcm9wZXJ0eSIsIm9BcmdzIiwiYXBwbHkiXSwibWFwcGluZ3MiOiI7QUFBQTtBQUNBO0FBQ0E7Ozs7OztBQUNBLE1BQU1BLG1CQUFtQixHQUFHLFVBQVNDLFdBQVQsRUFBc0M7QUFDakUsWUFBUUEsV0FBUjtBQUNDLFdBQUssT0FBTDtBQUNDLGVBQU8sQ0FBUDs7QUFDRCxXQUFLLFNBQUw7QUFDQyxlQUFPLENBQVA7O0FBQ0QsV0FBSyxhQUFMO0FBQ0MsZUFBTyxDQUFQOztBQUNELFdBQUssTUFBTDtBQUNDLGVBQU8sQ0FBUDs7QUFDRDtBQUNDLGVBQU8sQ0FBQyxDQUFSO0FBVkY7QUFZQSxHQWJEO0FBZUE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBOzs7QUFFQSxNQUFNQyxlQUFlLEdBQUcsVUFBOEJDLGdCQUE5QixFQUFpRUMsaUJBQWpFLEVBQXdHO0FBQy9ILFFBQUlDLHdCQUFnQyxHQUFHLENBQUMsQ0FBeEM7O0FBQ0EsUUFBSUQsaUJBQUosRUFBdUI7QUFDdEIsVUFBTUUsbUJBQW1CLEdBQUcsS0FBS0MsaUJBQUwsS0FBMkIsS0FBS0EsaUJBQUwsR0FBeUJDLE9BQXpCLEVBQTNCLEdBQWdFQyxTQUE1RjtBQUNBTCxNQUFBQSxpQkFBaUIsQ0FBQ00sT0FBbEIsQ0FBMEIsVUFBQ0MsUUFBRCxFQUFtQjtBQUM1QyxZQUFJQSxRQUFRLENBQUNDLFFBQVQsQ0FBa0IsQ0FBbEIsRUFBcUJDLE9BQXJCLENBQTZCUCxtQkFBN0IsTUFBc0QsQ0FBdEQsSUFBMkRELHdCQUF3QixHQUFHTCxtQkFBbUIsQ0FBQ1csUUFBUSxDQUFDRyxJQUFWLENBQTdHLEVBQThIO0FBQzdIVCxVQUFBQSx3QkFBd0IsR0FBR0wsbUJBQW1CLENBQUNXLFFBQVEsQ0FBQ0csSUFBVixDQUE5QztBQUNBWCxVQUFBQSxnQkFBZ0IsR0FBR1EsUUFBUSxDQUFDRyxJQUE1QjtBQUNBO0FBQ0QsT0FMRDtBQU1BOztBQUVELFFBQUlDLG1CQUFKOztBQUNBLFFBQUksT0FBT1osZ0JBQVAsS0FBNEIsUUFBaEMsRUFBMEM7QUFDekMsYUFBUUEsZ0JBQVI7QUFDQTs7QUFDRCxZQUFRQSxnQkFBUjtBQUNDLFdBQUssQ0FBTDtBQUNDWSxRQUFBQSxtQkFBbUIsR0FBR0MsV0FBVyxDQUFDQyxLQUFsQztBQUNBOztBQUNELFdBQUssQ0FBTDtBQUNDRixRQUFBQSxtQkFBbUIsR0FBR0MsV0FBVyxDQUFDRSxPQUFsQztBQUNBOztBQUNELFdBQUssQ0FBTDtBQUNDSCxRQUFBQSxtQkFBbUIsR0FBR0MsV0FBVyxDQUFDRyxPQUFsQztBQUNBOztBQUNELFdBQUssQ0FBTDtBQUNDSixRQUFBQSxtQkFBbUIsR0FBR0MsV0FBVyxDQUFDSSxXQUFsQztBQUNBOztBQUNEO0FBQ0NMLFFBQUFBLG1CQUFtQixHQUFHQyxXQUFXLENBQUNLLElBQWxDO0FBZEY7O0FBaUJBLFdBQU9OLG1CQUFQO0FBQ0EsR0FsQ0Q7O0FBbUNBYixFQUFBQSxlQUFlLENBQUNvQixjQUFoQixHQUFpQyx1REFBakM7O0FBRUEsTUFBTUMsWUFBWSxHQUFHLFVBQThCQyxZQUE5QixFQUFvRDtBQUN4RSxRQUFJLEtBQUtqQixpQkFBTCxNQUE0QmlCLFlBQWhDLEVBQThDO0FBQzdDLGFBQU9BLFlBQVksQ0FBQ1gsT0FBYixDQUFxQixLQUFLTixpQkFBTCxHQUF5QkMsT0FBekIsRUFBckIsTUFBNkQsQ0FBcEU7QUFDQSxLQUZELE1BRU87QUFDTixhQUFPLEtBQVA7QUFDQTtBQUNELEdBTkQ7O0FBT0FlLEVBQUFBLFlBQVksQ0FBQ0QsY0FBYixHQUE4QixvREFBOUIsQyxDQUVBOztBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7O0FBQ0EsTUFBTUcsZUFBZSxHQUFHLFVBQXVCQyxLQUF2QixFQUE0RDtBQUNuRixRQUFJRCxlQUFlLENBQUNFLGNBQWhCLENBQStCRCxLQUEvQixDQUFKLEVBQTJDO0FBQUEsd0NBRHFCRSxLQUNyQjtBQURxQkEsUUFBQUEsS0FDckI7QUFBQTs7QUFDMUMsYUFBUUgsZUFBRCxDQUF5QkMsS0FBekIsRUFBZ0NHLEtBQWhDLENBQXNDLElBQXRDLEVBQTRDRCxLQUE1QyxDQUFQO0FBQ0EsS0FGRCxNQUVPO0FBQ04sYUFBTyxFQUFQO0FBQ0E7QUFDRCxHQU5EOztBQVFBSCxFQUFBQSxlQUFlLENBQUN2QixlQUFoQixHQUFrQ0EsZUFBbEM7QUFDQXVCLEVBQUFBLGVBQWUsQ0FBQ0YsWUFBaEIsR0FBK0JBLFlBQS9CO0FBQ0E7QUFDQTtBQUNBOztTQUNlRSxlIiwic291cmNlUm9vdCI6Ii4iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNYW5hZ2VkT2JqZWN0IH0gZnJvbSBcInNhcC91aS9iYXNlXCI7XG5pbXBvcnQgeyBNZXNzYWdlVHlwZSB9IGZyb20gXCJzYXAvZmUvY29yZS9mb3JtYXR0ZXJzL1RhYmxlRm9ybWF0dGVyVHlwZXNcIjtcblxuY29uc3QgZ2V0TWVzc2FnZXR5cGVPcmRlciA9IGZ1bmN0aW9uKG1lc3NhZ2VUeXBlOiBzdHJpbmcpOiBudW1iZXIge1xuXHRzd2l0Y2ggKG1lc3NhZ2VUeXBlKSB7XG5cdFx0Y2FzZSBcIkVycm9yXCI6XG5cdFx0XHRyZXR1cm4gNDtcblx0XHRjYXNlIFwiV2FybmluZ1wiOlxuXHRcdFx0cmV0dXJuIDM7XG5cdFx0Y2FzZSBcIkluZm9ybWF0aW9uXCI6XG5cdFx0XHRyZXR1cm4gMjtcblx0XHRjYXNlIFwiTm9uZVwiOlxuXHRcdFx0cmV0dXJuIDE7XG5cdFx0ZGVmYXVsdDpcblx0XHRcdHJldHVybiAtMTtcblx0fVxufTtcblxuLyoqXG4gKiByb3dIaWdobGlnaHRpbmdcbiAqXG4gKiBAcGFyYW0ge29iamVjdH0gdGhpcyBUaGUgY29udGV4dFxuICogQHBhcmFtIHtzdHJpbmd8bnVtYmVyfSBDcml0aWNhbGl0eVZhbHVlIFRoZSBjcml0aWNhbGl0eSB2YWx1ZVxuICogQHBhcmFtIHtudW1iZXJ9IG1lc3NhZ2VMYXN0VXBkYXRlIFRpbWVzdGFtcCBvZiB0aGUgbGFzdCBtZXNzYWdlIHRoYXQgd2FzIGNyZWF0ZWQuIEl0J3MgZGVmaW5lZCBhcyBhbiBpbnB1dCB2YWx1ZSwgYnV0IG5vdCB1c2VkIGluIHRoZSBib2R5IG9mIHRoZSBmdW5jdGlvblxuICogSXQgaXMgdXNlZCB0byByZWZyZXNoIHRoZSBmb3JtYXR0aW5nIG9mIHRoZSB0YWJsZSBlYWNoIHRpbWUgYSBuZXcgbWVzc2FnZSBpcyB1cGRhdGVkXG4gKiBAcmV0dXJucyB7b2JqZWN0fSBUaGUgdmFsdWUgZnJvbSB0aGUgaW5uZXIgZnVuY3Rpb25cbiAqL1xuXG5jb25zdCByb3dIaWdobGlnaHRpbmcgPSBmdW5jdGlvbih0aGlzOiBNYW5hZ2VkT2JqZWN0LCBjcml0aWNhbGl0eVZhbHVlOiBzdHJpbmcgfCBudW1iZXIsIGFGaWx0ZXJlZE1lc3NhZ2VzOiBhbnlbXSk6IE1lc3NhZ2VUeXBlIHtcblx0bGV0IGlIaWdoZXN0Q3JpdGljYWxpdHlWYWx1ZTogbnVtYmVyID0gLTE7XG5cdGlmIChhRmlsdGVyZWRNZXNzYWdlcykge1xuXHRcdGNvbnN0IHNDdXJyZW50Q29udGV4dFBhdGggPSB0aGlzLmdldEJpbmRpbmdDb250ZXh0KCkgPyB0aGlzLmdldEJpbmRpbmdDb250ZXh0KCkuZ2V0UGF0aCgpIDogdW5kZWZpbmVkO1xuXHRcdGFGaWx0ZXJlZE1lc3NhZ2VzLmZvckVhY2goKG9NZXNzYWdlOiBhbnkpID0+IHtcblx0XHRcdGlmIChvTWVzc2FnZS5hVGFyZ2V0c1swXS5pbmRleE9mKHNDdXJyZW50Q29udGV4dFBhdGgpID09PSAwICYmIGlIaWdoZXN0Q3JpdGljYWxpdHlWYWx1ZSA8IGdldE1lc3NhZ2V0eXBlT3JkZXIob01lc3NhZ2UudHlwZSkpIHtcblx0XHRcdFx0aUhpZ2hlc3RDcml0aWNhbGl0eVZhbHVlID0gZ2V0TWVzc2FnZXR5cGVPcmRlcihvTWVzc2FnZS50eXBlKTtcblx0XHRcdFx0Y3JpdGljYWxpdHlWYWx1ZSA9IG9NZXNzYWdlLnR5cGU7XG5cdFx0XHR9XG5cdFx0fSk7XG5cdH1cblxuXHRsZXQgY3JpdGljYWxpdHlQcm9wZXJ0eTtcblx0aWYgKHR5cGVvZiBjcml0aWNhbGl0eVZhbHVlID09PSBcInN0cmluZ1wiKSB7XG5cdFx0cmV0dXJuIChjcml0aWNhbGl0eVZhbHVlIGFzIHVua25vd24pIGFzIE1lc3NhZ2VUeXBlO1xuXHR9XG5cdHN3aXRjaCAoY3JpdGljYWxpdHlWYWx1ZSkge1xuXHRcdGNhc2UgMTpcblx0XHRcdGNyaXRpY2FsaXR5UHJvcGVydHkgPSBNZXNzYWdlVHlwZS5FcnJvcjtcblx0XHRcdGJyZWFrO1xuXHRcdGNhc2UgMjpcblx0XHRcdGNyaXRpY2FsaXR5UHJvcGVydHkgPSBNZXNzYWdlVHlwZS5XYXJuaW5nO1xuXHRcdFx0YnJlYWs7XG5cdFx0Y2FzZSAzOlxuXHRcdFx0Y3JpdGljYWxpdHlQcm9wZXJ0eSA9IE1lc3NhZ2VUeXBlLlN1Y2Nlc3M7XG5cdFx0XHRicmVhaztcblx0XHRjYXNlIDU6XG5cdFx0XHRjcml0aWNhbGl0eVByb3BlcnR5ID0gTWVzc2FnZVR5cGUuSW5mb3JtYXRpb247XG5cdFx0XHRicmVhaztcblx0XHRkZWZhdWx0OlxuXHRcdFx0Y3JpdGljYWxpdHlQcm9wZXJ0eSA9IE1lc3NhZ2VUeXBlLk5vbmU7XG5cdH1cblxuXHRyZXR1cm4gY3JpdGljYWxpdHlQcm9wZXJ0eTtcbn07XG5yb3dIaWdobGlnaHRpbmcuX19mdW5jdGlvbk5hbWUgPSBcInNhcC5mZS5jb3JlLmZvcm1hdHRlcnMuVGFibGVGb3JtYXR0ZXIjcm93SGlnaGxpZ2h0aW5nXCI7XG5cbmNvbnN0IG5hdmlnYXRlZFJvdyA9IGZ1bmN0aW9uKHRoaXM6IE1hbmFnZWRPYmplY3QsIHNEZWVwZXN0UGF0aDogc3RyaW5nKSB7XG5cdGlmICh0aGlzLmdldEJpbmRpbmdDb250ZXh0KCkgJiYgc0RlZXBlc3RQYXRoKSB7XG5cdFx0cmV0dXJuIHNEZWVwZXN0UGF0aC5pbmRleE9mKHRoaXMuZ2V0QmluZGluZ0NvbnRleHQoKS5nZXRQYXRoKCkpID09PSAwO1xuXHR9IGVsc2Uge1xuXHRcdHJldHVybiBmYWxzZTtcblx0fVxufTtcbm5hdmlnYXRlZFJvdy5fX2Z1bmN0aW9uTmFtZSA9IFwic2FwLmZlLmNvcmUuZm9ybWF0dGVycy5UYWJsZUZvcm1hdHRlciNuYXZpZ2F0ZWRSb3dcIjtcblxuLy8gU2VlIGh0dHBzOi8vd3d3LnR5cGVzY3JpcHRsYW5nLm9yZy9kb2NzL2hhbmRib29rL2Z1bmN0aW9ucy5odG1sI3RoaXMtcGFyYW1ldGVycyBmb3IgbW9yZSBkZXRhaWwgb24gdGhpcyB3ZWlyZCBzeW50YXhcbi8qKlxuICogQ29sbGVjdGlvbiBvZiB0YWJsZSBmb3JtYXR0ZXJzLlxuICpcbiAqIEBwYXJhbSB7b2JqZWN0fSB0aGlzIFRoZSBjb250ZXh0XG4gKiBAcGFyYW0ge3N0cmluZ30gc05hbWUgVGhlIGlubmVyIGZ1bmN0aW9uIG5hbWVcbiAqIEBwYXJhbSB7b2JqZWN0W119IG9BcmdzIFRoZSBpbm5lciBmdW5jdGlvbiBwYXJhbWV0ZXJzXG4gKiBAcmV0dXJucyB7b2JqZWN0fSBUaGUgdmFsdWUgZnJvbSB0aGUgaW5uZXIgZnVuY3Rpb25cbiAqL1xuY29uc3QgdGFibGVGb3JtYXR0ZXJzID0gZnVuY3Rpb24odGhpczogb2JqZWN0LCBzTmFtZTogc3RyaW5nLCAuLi5vQXJnczogYW55W10pOiBhbnkge1xuXHRpZiAodGFibGVGb3JtYXR0ZXJzLmhhc093blByb3BlcnR5KHNOYW1lKSkge1xuXHRcdHJldHVybiAodGFibGVGb3JtYXR0ZXJzIGFzIGFueSlbc05hbWVdLmFwcGx5KHRoaXMsIG9BcmdzKTtcblx0fSBlbHNlIHtcblx0XHRyZXR1cm4gXCJcIjtcblx0fVxufTtcblxudGFibGVGb3JtYXR0ZXJzLnJvd0hpZ2hsaWdodGluZyA9IHJvd0hpZ2hsaWdodGluZztcbnRhYmxlRm9ybWF0dGVycy5uYXZpZ2F0ZWRSb3cgPSBuYXZpZ2F0ZWRSb3c7XG4vKipcbiAqIEBnbG9iYWxcbiAqL1xuZXhwb3J0IGRlZmF1bHQgdGFibGVGb3JtYXR0ZXJzO1xuIl19

package/packages/sap.fe.core/src/sap/fe/core/formatters/TableFormatter.js

@@ -2,4 +2,4 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2021 SAP SE. All rights reserved
  */
-sap.ui.define(["sap/fe/core/formatters/TableFormatterTypes"],function(T){"use strict";var M=T.MessageType;var r=function(c,f){if(f){var C=this.getBindingContext()?this.getBindingContext().getPath():undefined;f.forEach(function(m){if(m.aTargets[0].indexOf(C)===0){c=m.type;}});}var a;if(typeof c==="string"){return c;}switch(c){case 1:a=M.Error;break;case 2:a=M.Warning;break;case 3:a=M.Success;break;case 5:a=M.Information;break;default:a=M.None;}return a;};r.__functionName="sap.fe.core.formatters.TableFormatter#rowHighlighting";var n=function(d){if(this.getBindingContext()&&d){return d.indexOf(this.getBindingContext().getPath())===0;}else{return false;}};n.__functionName="sap.fe.core.formatters.TableFormatter#navigatedRow";var t=function(N){if(t.hasOwnProperty(N)){for(var _=arguments.length,a=new Array(_>1?_-1:0),b=1;b<_;b++){a[b-1]=arguments[b];}return t[N].apply(this,a);}else{return"";}};t.rowHighlighting=r;t.navigatedRow=n;return t;},true);
+sap.ui.define(["sap/fe/core/formatters/TableFormatterTypes"],function(T){"use strict";var M=T.MessageType;var g=function(m){switch(m){case"Error":return 4;case"Warning":return 3;case"Information":return 2;case"None":return 1;default:return-1;}};var r=function(c,f){var h=-1;if(f){var C=this.getBindingContext()?this.getBindingContext().getPath():undefined;f.forEach(function(m){if(m.aTargets[0].indexOf(C)===0&&h<g(m.type)){h=g(m.type);c=m.type;}});}var a;if(typeof c==="string"){return c;}switch(c){case 1:a=M.Error;break;case 2:a=M.Warning;break;case 3:a=M.Success;break;case 5:a=M.Information;break;default:a=M.None;}return a;};r.__functionName="sap.fe.core.formatters.TableFormatter#rowHighlighting";var n=function(d){if(this.getBindingContext()&&d){return d.indexOf(this.getBindingContext().getPath())===0;}else{return false;}};n.__functionName="sap.fe.core.formatters.TableFormatter#navigatedRow";var t=function(N){if(t.hasOwnProperty(N)){for(var _=arguments.length,a=new Array(_>1?_-1:0),b=1;b<_;b++){a[b-1]=arguments[b];}return t[N].apply(this,a);}else{return"";}};t.rowHighlighting=r;t.navigatedRow=n;return t;},true);

package/packages/sap.fe.core/src/sap/fe/core/formatters/TableFormatter.ts

@@ -1,21 +1,38 @@
 import { ManagedObject } from "sap/ui/base";
 import { MessageType } from "sap/fe/core/formatters/TableFormatterTypes";
 
+const getMessagetypeOrder = function(messageType: string): number {
+	switch (messageType) {
+		case "Error":
+			return 4;
+		case "Warning":
+			return 3;
+		case "Information":
+			return 2;
+		case "None":
+			return 1;
+		default:
+			return -1;
+	}
+};
+
 /**
  * rowHighlighting
  *
  * @param {object} this The context
- * @param {string|number} CriticalityValue criticality value
- * @param {number} messageLastUpdate Timestamp of the last message created,  It's defined as input value but it is not used in the body of the function
+ * @param {string|number} CriticalityValue The criticality value
+ * @param {number} messageLastUpdate Timestamp of the last message that was created. It's defined as an input value, but not used in the body of the function
  * It is used to refresh the formatting of the table each time a new message is updated
  * @returns {object} The value from the inner function
  */
 
 const rowHighlighting = function(this: ManagedObject, criticalityValue: string | number, aFilteredMessages: any[]): MessageType {
+	let iHighestCriticalityValue: number = -1;
 	if (aFilteredMessages) {
 		const sCurrentContextPath = this.getBindingContext() ? this.getBindingContext().getPath() : undefined;
 		aFilteredMessages.forEach((oMessage: any) => {
-			if (oMessage.aTargets[0].indexOf(sCurrentContextPath) === 0) {
+			if (oMessage.aTargets[0].indexOf(sCurrentContextPath) === 0 && iHighestCriticalityValue < getMessagetypeOrder(oMessage.type)) {
+				iHighestCriticalityValue = getMessagetypeOrder(oMessage.type);
 				criticalityValue = oMessage.type;
 			}
 		});

package/packages/sap.fe.core/src/sap/fe/core/fpm/manifest.json

@@ -4,7 +4,7 @@
 		"id": "sap.fe.core.fpm",
 		"type": "component",
 		"applicationVersion": {
-			"version": "1.96.0"
+			"version": "1.97.0"
 		},
 		"title": "Object Page",
 		"tags": {
@@ -45,7 +45,7 @@
 		},
 		"handleValidation": true,
 		"dependencies": {
-			"minUI5Version": "1.96.0",
+			"minUI5Version": "1.97.0",
 			"libs": {
 				"sap.f": {},
 				"sap.fe.macros": {},

package/packages/sap.fe.core/src/sap/fe/core/helpers/KeepAliveHelper-dbg.js

@@ -0,0 +1,211 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/Log", "sap/fe/core/helpers/ModelHelper", "sap/fe/core/helpers/KeepAliveRefreshTypes"], function (Log, ModelHelper, KeepAliveRefreshTypes) {
+  "use strict";
+
+  var PATH_TO_STORE = KeepAliveRefreshTypes.PATH_TO_STORE;
+  var RefreshStrategyType = KeepAliveRefreshTypes.RefreshStrategyType;
+  var getEntitySetPath = ModelHelper.getEntitySetPath;
+
+  // Private functions - start
+  var _fnSimplifyEntitySetPath = function (metaModel, entitySetPathToUse) {
+    var entitySetPath = getEntitySetPath(entitySetPathToUse);
+    var entitySet = entitySetPath.indexOf("$NavigationPropertyBinding") > -1 && metaModel.getObject(entitySetPath);
+    return entitySet ? "/" + entitySet : entitySetPathToUse;
+  };
+
+  var _fnIsApplicable = function (primaryPath, key, strategy) {
+    return primaryPath === key || strategy === RefreshStrategyType.IncludingDependents && primaryPath.startsWith(key);
+  };
+  /**
+   * Check if given path resides in the context path provided.
+   *
+   * @param {ODataMetaModel} metaModel MetaModel to be used
+   * @param {string} contextPath Context path to be used
+   * @param {string} path Path to be used
+   * @param {RefreshStrategyType} strategy Strategy, it could be 'self' | 'includingDependents'
+   * @returns {boolean} Returns true if the context path is applicable.
+   */
+
+
+  var _isPathApplicableToContextPath = function (metaModel, contextPath, path, strategy) {
+    var contextPathToCheck = contextPath.startsWith("/") ? contextPath : "/" + contextPath,
+        pathToCheck = path.startsWith("/") ? path : "/" + path;
+
+    if (!_fnIsApplicable(contextPathToCheck, pathToCheck, strategy)) {
+      contextPathToCheck = _fnSimplifyEntitySetPath(metaModel, contextPathToCheck);
+
+      if (!_fnIsApplicable(contextPathToCheck, pathToCheck, strategy)) {
+        pathToCheck = _fnSimplifyEntitySetPath(metaModel, pathToCheck);
+      } else {
+        return true;
+      }
+    }
+
+    return _fnIsApplicable(contextPathToCheck, pathToCheck, strategy);
+  }; // Private functions - end
+
+  /**
+   * Get controls to refresh in a view.
+   *
+   * @param {View} view View of the controls
+   * @param {Control[]} controls Context path to be used
+   * @returns {Control[]} Returns controls that need to be refreshed.
+   */
+
+
+  var getControlsForRefresh = function (view, controls) {
+    var controlsForRefresh = [];
+    var metaModel = view.getModel().getMetaModel();
+    var internalModel = view.getModel("internal");
+    var refreshStrategy = internalModel.getProperty(PATH_TO_STORE) || {};
+
+    if (controls) {
+      controls.forEach(function (control) {
+        var contextPath = control.data("targetCollectionPath");
+
+        for (var key in refreshStrategy) {
+          var strategy = refreshStrategy[key];
+
+          if (controlsForRefresh.indexOf(control) === -1 && _isPathApplicableToContextPath(metaModel, contextPath, key, strategy)) {
+            controlsForRefresh.push(control);
+          }
+        }
+      });
+    }
+
+    return controlsForRefresh;
+  };
+  /**
+   * Get refresh strategy for the control for a context path.
+   *
+   * @param {Control} control Control from which refresh info is needed
+   * @param {string} contextPath ContextPath for properities
+   * @returns {RefreshStrategyType} Returns strategy for control refresh.
+   */
+
+
+  var getControlRefreshStrategyForContextPath = function (control, contextPath) {
+    var metaModel = control.getModel().getMetaModel();
+    var internalModel = control.getModel("internal");
+    var refreshStrategy = internalModel.getProperty(PATH_TO_STORE) || {};
+    var strategy;
+
+    if (contextPath) {
+      for (var key in refreshStrategy) {
+        var strategyToCheck = refreshStrategy[key];
+
+        if (_isPathApplicableToContextPath(metaModel, contextPath, key, strategyToCheck)) {
+          strategy = strategyToCheck;
+
+          if (strategy === "includingDependents") {
+            break;
+          }
+        }
+      }
+    }
+
+    return strategy;
+  };
+  /**
+   * Get refresh info from view.
+   *
+   * @param {View} view View from which refresh info is needed
+   * @returns {RefreshStrategyType | undefined} Returns strategy for view refresh.
+   */
+
+
+  var getViewRefreshInfo = function (view) {
+    var viewData = view.getViewData(),
+        contextPath = viewData && ((viewData === null || viewData === void 0 ? void 0 : viewData.contextPath) || "/" + (viewData === null || viewData === void 0 ? void 0 : viewData.entitySet));
+    return KeepAliveHelper.getControlRefreshStrategyForContextPath(view, contextPath);
+  };
+  /**
+   * Get refresh strategy for an intent.
+   *
+   * @param {RefreshStrategies} refreshStrategies RefreshStrategies to consider
+   * @param {string} semanticObject Outbound Semantic Object
+   * @param {string} action Outbound Action
+   * @returns {SORefreshStrategy | undefined} Returns refresh strategies to use for the intent.
+   */
+
+
+  var getRefreshStrategyForIntent = function (refreshStrategies, semanticObject, action) {
+    var soAction = semanticObject && action && semanticObject + "-" + action;
+    var intents = refreshStrategies.intents;
+    var soActionIntentMatch = intents && soAction && intents[soAction];
+    var soIntentMatch = !soActionIntentMatch && intents && semanticObject && intents[semanticObject];
+    return soActionIntentMatch || soIntentMatch || (refreshStrategies === null || refreshStrategies === void 0 ? void 0 : refreshStrategies.defaultBehavior) || (refreshStrategies === null || refreshStrategies === void 0 ? void 0 : refreshStrategies._feDefault);
+  };
+  /**
+   * Store control refresh strategy for hash in the internal model.
+   *
+   * @param {Control} control Control for the refresh strategy
+   * @param {SOAction} hash Shell hash object
+   */
+
+
+  var storeControlRefreshStrategyForHash = function (control, hash) {
+    if (control && control.getModel("viewData") && control.getModel("internal")) {
+      var viewData = control.getModel("viewData");
+      var refreshStrategies = viewData.getProperty(PATH_TO_STORE);
+
+      if (refreshStrategies) {
+        var internalModel = control.getModel("internal");
+        var refreshStrategy = KeepAliveHelper.getRefreshStrategyForIntent(refreshStrategies, hash === null || hash === void 0 ? void 0 : hash.semanticObject, hash === null || hash === void 0 ? void 0 : hash.action);
+        internalModel.setProperty(PATH_TO_STORE, refreshStrategy);
+      }
+    }
+  };
+  /**
+   * Method to refresh and restore the view if neccessary.
+   *
+   * @param {object} view Control for the refresh strategy
+   * @returns {object} A promise after view refresh and restore are triggered
+   */
+
+
+  var restoreView = function (view) {
+    var internalModelContext = view.getBindingContext("internal");
+    var controller = view.getController();
+    var viewState = controller === null || controller === void 0 ? void 0 : controller.viewState;
+    var refreshBindings = Promise.resolve();
+
+    if (internalModelContext.getProperty("restoreStatus") === "pending") {
+      if (viewState.refreshViewBindings) {
+        refreshBindings = viewState.refreshViewBindings();
+        refreshBindings.then(function () {
+          Log.info("FE V4: Refresh was triggered successfull: " + view.getId());
+        }).catch(function (err) {
+          Log.warning("FE V4: Refresh was unsuccessfull: " + view.getId(), err);
+        });
+      }
+
+      refreshBindings = refreshBindings.then(function () {
+        viewState.onRestore();
+        internalModelContext.setProperty("restoreStatus", "done");
+      }).catch(function (error) {
+        Log.warning("FE V4: Restore was unsuccessfull: " + view.getId(), error);
+      });
+    }
+
+    return refreshBindings;
+  };
+  /**
+   * helper class for KeepAlive feature in sap.fe.
+   */
+
+
+  var KeepAliveHelper = {
+    getControlsForRefresh: getControlsForRefresh,
+    getControlRefreshStrategyForContextPath: getControlRefreshStrategyForContextPath,
+    getViewRefreshInfo: getViewRefreshInfo,
+    getRefreshStrategyForIntent: getRefreshStrategyForIntent,
+    storeControlRefreshStrategyForHash: storeControlRefreshStrategyForHash,
+    restoreView: restoreView
+  };
+  return KeepAliveHelper;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["KeepAliveHelper.ts"],"names":["_fnSimplifyEntitySetPath","metaModel","entitySetPathToUse","entitySetPath","getEntitySetPath","entitySet","indexOf","getObject","_fnIsApplicable","primaryPath","key","strategy","RefreshStrategyType","IncludingDependents","startsWith","_isPathApplicableToContextPath","contextPath","path","contextPathToCheck","pathToCheck","getControlsForRefresh","view","controls","controlsForRefresh","getModel","getMetaModel","internalModel","refreshStrategy","getProperty","PATH_TO_STORE","forEach","control","data","push","getControlRefreshStrategyForContextPath","strategyToCheck","getViewRefreshInfo","viewData","getViewData","KeepAliveHelper","getRefreshStrategyForIntent","refreshStrategies","semanticObject","action","soAction","intents","soActionIntentMatch","soIntentMatch","defaultBehavior","_feDefault","storeControlRefreshStrategyForHash","hash","setProperty","restoreView","internalModelContext","getBindingContext","controller","getController","viewState","refreshBindings","Promise","resolve","refreshViewBindings","then","Log","info","getId","catch","err","warning","onRestore","error"],"mappings":"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","sourceRoot":".","sourcesContent":["import { Control } from \"sap/ui/core\";\nimport { View } from \"sap/ui/core/mvc\";\nimport { Log } from \"sap/base\";\nimport { ODataMetaModel } from \"sap/ui/model/odata/v4\";\nimport { getEntitySetPath } from \"sap/fe/core/helpers/ModelHelper\";\nimport { BaseManifestSettings } from \"sap/fe/core/converters/ManifestSettings\";\nimport { JSONModel } from \"sap/ui/model/json\";\nimport {\n\tRefreshStrategyType,\n\tSORefreshStrategy,\n\tRefreshStrategies,\n\tPATH_TO_STORE,\n\tSOAction\n} from \"sap/fe/core/helpers/KeepAliveRefreshTypes\";\n\n// Private functions - start\nconst _fnSimplifyEntitySetPath = function(metaModel: ODataMetaModel, entitySetPathToUse: string): string {\n\tconst entitySetPath = getEntitySetPath(entitySetPathToUse);\n\tconst entitySet = entitySetPath.indexOf(\"$NavigationPropertyBinding\") > -1 && metaModel.getObject(entitySetPath);\n\treturn entitySet ? \"/\" + entitySet : entitySetPathToUse;\n};\nconst _fnIsApplicable = function(primaryPath: string, key: string, strategy: RefreshStrategyType): boolean {\n\treturn primaryPath === key || (strategy === RefreshStrategyType.IncludingDependents && primaryPath.startsWith(key));\n};\n/**\n * Check if given path resides in the context path provided.\n *\n * @param {ODataMetaModel} metaModel MetaModel to be used\n * @param {string} contextPath Context path to be used\n * @param {string} path Path to be used\n * @param {RefreshStrategyType} strategy Strategy, it could be 'self' | 'includingDependents'\n * @returns {boolean} Returns true if the context path is applicable.\n */\nconst _isPathApplicableToContextPath = function(\n\tmetaModel: ODataMetaModel,\n\tcontextPath: string,\n\tpath: string,\n\tstrategy: RefreshStrategyType\n): boolean {\n\tlet contextPathToCheck = contextPath.startsWith(\"/\") ? contextPath : \"/\" + contextPath,\n\t\tpathToCheck = path.startsWith(\"/\") ? path : \"/\" + path;\n\tif (!_fnIsApplicable(contextPathToCheck, pathToCheck, strategy)) {\n\t\tcontextPathToCheck = _fnSimplifyEntitySetPath(metaModel, contextPathToCheck);\n\t\tif (!_fnIsApplicable(contextPathToCheck, pathToCheck, strategy)) {\n\t\t\tpathToCheck = _fnSimplifyEntitySetPath(metaModel, pathToCheck);\n\t\t} else {\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn _fnIsApplicable(contextPathToCheck, pathToCheck, strategy);\n};\n// Private functions - end\n/**\n * Get controls to refresh in a view.\n *\n * @param {View} view View of the controls\n * @param {Control[]} controls Context path to be used\n * @returns {Control[]} Returns controls that need to be refreshed.\n */\nconst getControlsForRefresh = function(view: View, controls: Control[]): Control[] {\n\tconst controlsForRefresh: Control[] = [];\n\tconst metaModel = view.getModel().getMetaModel() as ODataMetaModel;\n\tconst internalModel = view.getModel(\"internal\");\n\tconst refreshStrategy = internalModel.getProperty(PATH_TO_STORE) || {};\n\tif (controls) {\n\t\tcontrols.forEach(function(control) {\n\t\t\tconst contextPath = control.data(\"targetCollectionPath\");\n\t\t\tfor (const key in refreshStrategy) {\n\t\t\t\tconst strategy = refreshStrategy[key];\n\t\t\t\tif (controlsForRefresh.indexOf(control) === -1 && _isPathApplicableToContextPath(metaModel, contextPath, key, strategy)) {\n\t\t\t\t\tcontrolsForRefresh.push(control);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n\treturn controlsForRefresh;\n};\n/**\n * Get refresh strategy for the control for a context path.\n *\n * @param {Control} control Control from which refresh info is needed\n * @param {string} contextPath ContextPath for properities\n * @returns {RefreshStrategyType} Returns strategy for control refresh.\n */\nconst getControlRefreshStrategyForContextPath = function(control: Control, contextPath: string): RefreshStrategyType | undefined {\n\tconst metaModel = control.getModel().getMetaModel() as ODataMetaModel;\n\tconst internalModel = control.getModel(\"internal\");\n\tconst refreshStrategy = internalModel.getProperty(PATH_TO_STORE) || {};\n\tlet strategy;\n\tif (contextPath) {\n\t\tfor (const key in refreshStrategy) {\n\t\t\tconst strategyToCheck = refreshStrategy[key];\n\t\t\tif (_isPathApplicableToContextPath(metaModel, contextPath, key, strategyToCheck)) {\n\t\t\t\tstrategy = strategyToCheck;\n\t\t\t\tif (strategy === \"includingDependents\") {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn strategy;\n};\n/**\n * Get refresh info from view.\n *\n * @param {View} view View from which refresh info is needed\n * @returns {RefreshStrategyType | undefined} Returns strategy for view refresh.\n */\nconst getViewRefreshInfo = function(view: View): RefreshStrategyType | undefined {\n\tconst viewData = view.getViewData() as BaseManifestSettings,\n\t\tcontextPath = viewData && (viewData?.contextPath || \"/\" + viewData?.entitySet);\n\treturn KeepAliveHelper.getControlRefreshStrategyForContextPath(view, contextPath);\n};\n\n/**\n * Get refresh strategy for an intent.\n *\n * @param {RefreshStrategies} refreshStrategies RefreshStrategies to consider\n * @param {string} semanticObject Outbound Semantic Object\n * @param {string} action Outbound Action\n * @returns {SORefreshStrategy | undefined} Returns refresh strategies to use for the intent.\n */\nconst getRefreshStrategyForIntent = function(\n\trefreshStrategies: RefreshStrategies,\n\tsemanticObject?: string,\n\taction?: string\n): SORefreshStrategy | undefined {\n\tconst soAction = semanticObject && action && semanticObject + \"-\" + action;\n\tconst intents = refreshStrategies.intents;\n\tconst soActionIntentMatch = intents && soAction && intents[soAction];\n\tconst soIntentMatch = !soActionIntentMatch && intents && semanticObject && intents[semanticObject];\n\n\treturn soActionIntentMatch || soIntentMatch || refreshStrategies?.defaultBehavior || refreshStrategies?._feDefault;\n};\n/**\n * Store control refresh strategy for hash in the internal model.\n *\n * @param {Control} control Control for the refresh strategy\n * @param {SOAction} hash Shell hash object\n */\nconst storeControlRefreshStrategyForHash = function(control: Control, hash: SOAction): void {\n\tif (control && control.getModel(\"viewData\") && control.getModel(\"internal\")) {\n\t\tconst viewData = control.getModel(\"viewData\");\n\t\tconst refreshStrategies: RefreshStrategies = viewData.getProperty(PATH_TO_STORE);\n\t\tif (refreshStrategies) {\n\t\t\tconst internalModel = control.getModel(\"internal\");\n\t\t\tconst refreshStrategy: SORefreshStrategy | undefined = KeepAliveHelper.getRefreshStrategyForIntent(\n\t\t\t\trefreshStrategies,\n\t\t\t\thash?.semanticObject,\n\t\t\t\thash?.action\n\t\t\t);\n\t\t\t(internalModel as JSONModel<{}>).setProperty(PATH_TO_STORE, refreshStrategy);\n\t\t}\n\t}\n};\n\n/**\n * Method to refresh and restore the view if neccessary.\n *\n * @param {object} view Control for the refresh strategy\n * @returns {object} A promise after view refresh and restore are triggered\n */\nconst restoreView = function(view: View): Promise<any> {\n\tconst internalModelContext = view.getBindingContext(\"internal\");\n\tconst controller = view.getController();\n\tconst viewState = (controller as any)?.viewState;\n\tlet refreshBindings = Promise.resolve();\n\tif (internalModelContext.getProperty(\"restoreStatus\") === \"pending\") {\n\t\tif (viewState.refreshViewBindings) {\n\t\t\trefreshBindings = viewState.refreshViewBindings();\n\t\t\trefreshBindings\n\t\t\t\t.then(function() {\n\t\t\t\t\tLog.info(\"FE V4: Refresh was triggered successfull: \" + view.getId());\n\t\t\t\t})\n\t\t\t\t.catch(function(err) {\n\t\t\t\t\tLog.warning(\"FE V4: Refresh was unsuccessfull: \" + view.getId(), err);\n\t\t\t\t});\n\t\t}\n\t\trefreshBindings = refreshBindings\n\t\t\t.then(function() {\n\t\t\t\tviewState.onRestore();\n\t\t\t\tinternalModelContext.setProperty(\"restoreStatus\", \"done\");\n\t\t\t})\n\t\t\t.catch(function(error) {\n\t\t\t\tLog.warning(\"FE V4: Restore was unsuccessfull: \" + view.getId(), error);\n\t\t\t});\n\t}\n\treturn refreshBindings;\n};\n\n/**\n * helper class for KeepAlive feature in sap.fe.\n */\nconst KeepAliveHelper = {\n\tgetControlsForRefresh,\n\tgetControlRefreshStrategyForContextPath,\n\tgetViewRefreshInfo,\n\tgetRefreshStrategyForIntent,\n\tstoreControlRefreshStrategyForHash,\n\trestoreView\n};\nexport default KeepAliveHelper;\n"]}

package/packages/sap.fe.core/src/sap/fe/core/helpers/KeepAliveHelper.js

@@ -0,0 +1,5 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/Log","sap/fe/core/helpers/ModelHelper","sap/fe/core/helpers/KeepAliveRefreshTypes"],function(L,M,K){"use strict";var P=K.PATH_TO_STORE;var R=K.RefreshStrategyType;var g=M.getEntitySetPath;var _=function(m,i){var j=g(i);var k=j.indexOf("$NavigationPropertyBinding")>-1&&m.getObject(j);return k?"/"+k:i;};var a=function(p,k,i){return p===k||i===R.IncludingDependents&&p.startsWith(k);};var b=function(m,i,p,j){var k=i.startsWith("/")?i:"/"+i,l=p.startsWith("/")?p:"/"+p;if(!a(k,l,j)){k=_(m,k);if(!a(k,l,j)){l=_(m,l);}else{return true;}}return a(k,l,j);};var c=function(v,i){var j=[];var m=v.getModel().getMetaModel();var k=v.getModel("internal");var l=k.getProperty(P)||{};if(i){i.forEach(function(n){var o=n.data("targetCollectionPath");for(var p in l){var q=l[p];if(j.indexOf(n)===-1&&b(m,o,p,q)){j.push(n);}}});}return j;};var d=function(i,j){var m=i.getModel().getMetaModel();var k=i.getModel("internal");var l=k.getProperty(P)||{};var n;if(j){for(var o in l){var p=l[o];if(b(m,j,o,p)){n=p;if(n==="includingDependents"){break;}}}}return n;};var e=function(v){var i=v.getViewData(),j=i&&((i===null||i===void 0?void 0:i.contextPath)||"/"+(i===null||i===void 0?void 0:i.entitySet));return h.getControlRefreshStrategyForContextPath(v,j);};var f=function(i,j,k){var l=j&&k&&j+"-"+k;var m=i.intents;var n=m&&l&&m[l];var o=!n&&m&&j&&m[j];return n||o||(i===null||i===void 0?void 0:i.defaultBehavior)||(i===null||i===void 0?void 0:i._feDefault);};var s=function(i,j){if(i&&i.getModel("viewData")&&i.getModel("internal")){var v=i.getModel("viewData");var k=v.getProperty(P);if(k){var l=i.getModel("internal");var m=h.getRefreshStrategyForIntent(k,j===null||j===void 0?void 0:j.semanticObject,j===null||j===void 0?void 0:j.action);l.setProperty(P,m);}}};var r=function(v){var i=v.getBindingContext("internal");var j=v.getController();var k=j===null||j===void 0?void 0:j.viewState;var l=Promise.resolve();if(i.getProperty("restoreStatus")==="pending"){if(k.refreshViewBindings){l=k.refreshViewBindings();l.then(function(){L.info("FE V4: Refresh was triggered successfull: "+v.getId());}).catch(function(m){L.warning("FE V4: Refresh was unsuccessfull: "+v.getId(),m);});}l=l.then(function(){k.onRestore();i.setProperty("restoreStatus","done");}).catch(function(m){L.warning("FE V4: Restore was unsuccessfull: "+v.getId(),m);});}return l;};var h={getControlsForRefresh:c,getControlRefreshStrategyForContextPath:d,getViewRefreshInfo:e,getRefreshStrategyForIntent:f,storeControlRefreshStrategyForHash:s,restoreView:r};return h;},false);

package/packages/sap.fe.core/src/sap/fe/core/helpers/KeepAliveHelper.ts

@@ -0,0 +1,202 @@
+import { Control } from "sap/ui/core";
+import { View } from "sap/ui/core/mvc";
+import { Log } from "sap/base";
+import { ODataMetaModel } from "sap/ui/model/odata/v4";
+import { getEntitySetPath } from "sap/fe/core/helpers/ModelHelper";
+import { BaseManifestSettings } from "sap/fe/core/converters/ManifestSettings";
+import { JSONModel } from "sap/ui/model/json";
+import {
+	RefreshStrategyType,
+	SORefreshStrategy,
+	RefreshStrategies,
+	PATH_TO_STORE,
+	SOAction
+} from "sap/fe/core/helpers/KeepAliveRefreshTypes";
+
+// Private functions - start
+const _fnSimplifyEntitySetPath = function(metaModel: ODataMetaModel, entitySetPathToUse: string): string {
+	const entitySetPath = getEntitySetPath(entitySetPathToUse);
+	const entitySet = entitySetPath.indexOf("$NavigationPropertyBinding") > -1 && metaModel.getObject(entitySetPath);
+	return entitySet ? "/" + entitySet : entitySetPathToUse;
+};
+const _fnIsApplicable = function(primaryPath: string, key: string, strategy: RefreshStrategyType): boolean {
+	return primaryPath === key || (strategy === RefreshStrategyType.IncludingDependents && primaryPath.startsWith(key));
+};
+/**
+ * Check if given path resides in the context path provided.
+ *
+ * @param {ODataMetaModel} metaModel MetaModel to be used
+ * @param {string} contextPath Context path to be used
+ * @param {string} path Path to be used
+ * @param {RefreshStrategyType} strategy Strategy, it could be 'self' | 'includingDependents'
+ * @returns {boolean} Returns true if the context path is applicable.
+ */
+const _isPathApplicableToContextPath = function(
+	metaModel: ODataMetaModel,
+	contextPath: string,
+	path: string,
+	strategy: RefreshStrategyType
+): boolean {
+	let contextPathToCheck = contextPath.startsWith("/") ? contextPath : "/" + contextPath,
+		pathToCheck = path.startsWith("/") ? path : "/" + path;
+	if (!_fnIsApplicable(contextPathToCheck, pathToCheck, strategy)) {
+		contextPathToCheck = _fnSimplifyEntitySetPath(metaModel, contextPathToCheck);
+		if (!_fnIsApplicable(contextPathToCheck, pathToCheck, strategy)) {
+			pathToCheck = _fnSimplifyEntitySetPath(metaModel, pathToCheck);
+		} else {
+			return true;
+		}
+	}
+	return _fnIsApplicable(contextPathToCheck, pathToCheck, strategy);
+};
+// Private functions - end
+/**
+ * Get controls to refresh in a view.
+ *
+ * @param {View} view View of the controls
+ * @param {Control[]} controls Context path to be used
+ * @returns {Control[]} Returns controls that need to be refreshed.
+ */
+const getControlsForRefresh = function(view: View, controls: Control[]): Control[] {
+	const controlsForRefresh: Control[] = [];
+	const metaModel = view.getModel().getMetaModel() as ODataMetaModel;
+	const internalModel = view.getModel("internal");
+	const refreshStrategy = internalModel.getProperty(PATH_TO_STORE) || {};
+	if (controls) {
+		controls.forEach(function(control) {
+			const contextPath = control.data("targetCollectionPath");
+			for (const key in refreshStrategy) {
+				const strategy = refreshStrategy[key];
+				if (controlsForRefresh.indexOf(control) === -1 && _isPathApplicableToContextPath(metaModel, contextPath, key, strategy)) {
+					controlsForRefresh.push(control);
+				}
+			}
+		});
+	}
+	return controlsForRefresh;
+};
+/**
+ * Get refresh strategy for the control for a context path.
+ *
+ * @param {Control} control Control from which refresh info is needed
+ * @param {string} contextPath ContextPath for properities
+ * @returns {RefreshStrategyType} Returns strategy for control refresh.
+ */
+const getControlRefreshStrategyForContextPath = function(control: Control, contextPath: string): RefreshStrategyType | undefined {
+	const metaModel = control.getModel().getMetaModel() as ODataMetaModel;
+	const internalModel = control.getModel("internal");
+	const refreshStrategy = internalModel.getProperty(PATH_TO_STORE) || {};
+	let strategy;
+	if (contextPath) {
+		for (const key in refreshStrategy) {
+			const strategyToCheck = refreshStrategy[key];
+			if (_isPathApplicableToContextPath(metaModel, contextPath, key, strategyToCheck)) {
+				strategy = strategyToCheck;
+				if (strategy === "includingDependents") {
+					break;
+				}
+			}
+		}
+	}
+	return strategy;
+};
+/**
+ * Get refresh info from view.
+ *
+ * @param {View} view View from which refresh info is needed
+ * @returns {RefreshStrategyType | undefined} Returns strategy for view refresh.
+ */
+const getViewRefreshInfo = function(view: View): RefreshStrategyType | undefined {
+	const viewData = view.getViewData() as BaseManifestSettings,
+		contextPath = viewData && (viewData?.contextPath || "/" + viewData?.entitySet);
+	return KeepAliveHelper.getControlRefreshStrategyForContextPath(view, contextPath);
+};
+
+/**
+ * Get refresh strategy for an intent.
+ *
+ * @param {RefreshStrategies} refreshStrategies RefreshStrategies to consider
+ * @param {string} semanticObject Outbound Semantic Object
+ * @param {string} action Outbound Action
+ * @returns {SORefreshStrategy | undefined} Returns refresh strategies to use for the intent.
+ */
+const getRefreshStrategyForIntent = function(
+	refreshStrategies: RefreshStrategies,
+	semanticObject?: string,
+	action?: string
+): SORefreshStrategy | undefined {
+	const soAction = semanticObject && action && semanticObject + "-" + action;
+	const intents = refreshStrategies.intents;
+	const soActionIntentMatch = intents && soAction && intents[soAction];
+	const soIntentMatch = !soActionIntentMatch && intents && semanticObject && intents[semanticObject];
+
+	return soActionIntentMatch || soIntentMatch || refreshStrategies?.defaultBehavior || refreshStrategies?._feDefault;
+};
+/**
+ * Store control refresh strategy for hash in the internal model.
+ *
+ * @param {Control} control Control for the refresh strategy
+ * @param {SOAction} hash Shell hash object
+ */
+const storeControlRefreshStrategyForHash = function(control: Control, hash: SOAction): void {
+	if (control && control.getModel("viewData") && control.getModel("internal")) {
+		const viewData = control.getModel("viewData");
+		const refreshStrategies: RefreshStrategies = viewData.getProperty(PATH_TO_STORE);
+		if (refreshStrategies) {
+			const internalModel = control.getModel("internal");
+			const refreshStrategy: SORefreshStrategy | undefined = KeepAliveHelper.getRefreshStrategyForIntent(
+				refreshStrategies,
+				hash?.semanticObject,
+				hash?.action
+			);
+			(internalModel as JSONModel<{}>).setProperty(PATH_TO_STORE, refreshStrategy);
+		}
+	}
+};
+
+/**
+ * Method to refresh and restore the view if neccessary.
+ *
+ * @param {object} view Control for the refresh strategy
+ * @returns {object} A promise after view refresh and restore are triggered
+ */
+const restoreView = function(view: View): Promise<any> {
+	const internalModelContext = view.getBindingContext("internal");
+	const controller = view.getController();
+	const viewState = (controller as any)?.viewState;
+	let refreshBindings = Promise.resolve();
+	if (internalModelContext.getProperty("restoreStatus") === "pending") {
+		if (viewState.refreshViewBindings) {
+			refreshBindings = viewState.refreshViewBindings();
+			refreshBindings
+				.then(function() {
+					Log.info("FE V4: Refresh was triggered successfull: " + view.getId());
+				})
+				.catch(function(err) {
+					Log.warning("FE V4: Refresh was unsuccessfull: " + view.getId(), err);
+				});
+		}
+		refreshBindings = refreshBindings
+			.then(function() {
+				viewState.onRestore();
+				internalModelContext.setProperty("restoreStatus", "done");
+			})
+			.catch(function(error) {
+				Log.warning("FE V4: Restore was unsuccessfull: " + view.getId(), error);
+			});
+	}
+	return refreshBindings;
+};
+
+/**
+ * helper class for KeepAlive feature in sap.fe.
+ */
+const KeepAliveHelper = {
+	getControlsForRefresh,
+	getControlRefreshStrategyForContextPath,
+	getViewRefreshInfo,
+	getRefreshStrategyForIntent,
+	storeControlRefreshStrategyForHash,
+	restoreView
+};
+export default KeepAliveHelper;

package/packages/sap.fe.core/src/sap/fe/core/helpers/KeepAliveRefreshTypes-dbg.js

@@ -0,0 +1,32 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define([], function () {
+  "use strict";
+
+  var _exports = {};
+
+  /**
+   * Enumeration for supported refresh strategy type
+   */
+  var RefreshStrategyType;
+  /**
+   * Configuration of a RefreshStrategy
+   */
+
+  (function (RefreshStrategyType) {
+    RefreshStrategyType["Self"] = "self";
+    RefreshStrategyType["IncludingDependents"] = "includingDependents";
+  })(RefreshStrategyType || (RefreshStrategyType = {}));
+
+  _exports.RefreshStrategyType = RefreshStrategyType;
+
+  /**
+   * Path used to store information
+   */
+  var PATH_TO_STORE = "/refreshStrategyOnAppRestore";
+  _exports.PATH_TO_STORE = PATH_TO_STORE;
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIktlZXBBbGl2ZVJlZnJlc2hUeXBlcy50cyJdLCJuYW1lcyI6WyJSZWZyZXNoU3RyYXRlZ3lUeXBlIiwiUEFUSF9UT19TVE9SRSJdLCJtYXBwaW5ncyI6IjtBQUFBO0FBQ0E7QUFDQTs7Ozs7O0FBRkE7QUFDQTtBQUNBO01BQ1lBLG1CO0FBSVo7QUFDQTtBQUNBOzthQU5ZQSxtQjtBQUFBQSxJQUFBQSxtQjtBQUFBQSxJQUFBQSxtQjtLQUFBQSxtQixLQUFBQSxtQjs7OztBQTZCWjtBQUNBO0FBQ0E7QUFDTyxNQUFNQyxhQUFxQixHQUFHLDhCQUE5QiIsInNvdXJjZVJvb3QiOiIuIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFbnVtZXJhdGlvbiBmb3Igc3VwcG9ydGVkIHJlZnJlc2ggc3RyYXRlZ3kgdHlwZVxuICovXG5leHBvcnQgZW51bSBSZWZyZXNoU3RyYXRlZ3lUeXBlIHtcblx0U2VsZiA9IFwic2VsZlwiLFxuXHRJbmNsdWRpbmdEZXBlbmRlbnRzID0gXCJpbmNsdWRpbmdEZXBlbmRlbnRzXCJcbn1cbi8qKlxuICogQ29uZmlndXJhdGlvbiBvZiBhIFJlZnJlc2hTdHJhdGVneVxuICovXG5leHBvcnQgdHlwZSBTT1JlZnJlc2hTdHJhdGVneSA9IHtcblx0W2VudGl0eVNldE5hbWVPckNvbnRleHRQYXRoOiBzdHJpbmddOiBSZWZyZXNoU3RyYXRlZ3lUeXBlO1xufTtcbi8qKlxuICogQ29uZmlndXJhdGlvbiBvZiBhIFJlZnJlc2hTdHJhdGVnaWVzXG4gKi9cbmV4cG9ydCB0eXBlIFJlZnJlc2hTdHJhdGVnaWVzID0ge1xuXHRpbnRlbnRzPzoge1xuXHRcdFtzb0FjdGlvbjogc3RyaW5nXTogU09SZWZyZXNoU3RyYXRlZ3k7IC8vICdzb0FjdGlvbicgZm9ybWF0IGlzIFwiPFNlbWFudGljT2JqZWN0Pi08QWN0aW9uPlwiXG5cdH07XG5cdGRlZmF1bHRCZWhhdmlvcj86IFNPUmVmcmVzaFN0cmF0ZWd5O1xuXHRfZmVEZWZhdWx0PzogU09SZWZyZXNoU3RyYXRlZ3k7XG59O1xuXG4vKipcbiAqIENvbmZpZ3VyYXRpb24gZm9yIGhhc2ggd2l0aCBzZW1hbnRpY09iamVjdCBhbmQgYWN0aW9uXG4gKi9cbmV4cG9ydCB0eXBlIFNPQWN0aW9uID0ge1xuXHRzZW1hbnRpY09iamVjdD86IHN0cmluZztcblx0YWN0aW9uPzogc3RyaW5nO1xufTtcblxuLyoqXG4gKiBQYXRoIHVzZWQgdG8gc3RvcmUgaW5mb3JtYXRpb25cbiAqL1xuZXhwb3J0IGNvbnN0IFBBVEhfVE9fU1RPUkU6IHN0cmluZyA9IFwiL3JlZnJlc2hTdHJhdGVneU9uQXBwUmVzdG9yZVwiO1xuIl19