@sapui5/sap.fe.core 1.95.0 → 1.98.0

package/src/sap/fe/core/helpers/BindingExpression.ts

@@ -87,6 +87,11 @@ export type ConcatExpression = BaseExpression<string> & {
 	expressions: Expression<string>[];
 };
 
+export type LengthExpression = BaseExpression<string> & {
+	_type: "Length";
+	bindingExpression: BindingExpressionExpression<any>;
+};
+
 export type UnresolveableBindingExpression = BaseExpression<string> & {
 	_type: "Unresolveable";
 };
@@ -154,6 +159,7 @@ export type Expression<T> =
 	| NotExpression
 	| TruthyExpression
 	| ConcatExpression
+	| LengthExpression
 	| BindingExpressionExpression<T>
 	| EmbeddedBindingExpression<T>
 	| EmbeddedExpressionBindingExpression<T>
@@ -245,6 +251,9 @@ export function _checkExpressionsAreEqual<T>(a: Expression<T>, b: Expression<T>)
 				return _checkExpressionsAreEqual(expression, bExpressions[index]);
 			});
 
+		case "Length":
+			return _checkExpressionsAreEqual(a.bindingExpression, (b as LengthExpression).bindingExpression);
+
 		case "Binding":
 			return (
 				a.modelName === (b as BindingExpressionExpression<T>).modelName &&
@@ -989,6 +998,16 @@ function comparison<T extends PrimitiveType>(
 	}
 }
 
+export function length(bindingExpression: BindingExpressionExpression<any> | UnresolveableBindingExpression): Expression<number> {
+	if (bindingExpression._type === "Unresolveable") {
+		return bindingExpression;
+	}
+	return {
+		_type: "Length",
+		bindingExpression
+	};
+}
+
 /**
  * Comparison: "equal" (===).
  *
@@ -1013,6 +1032,9 @@ export function equal<T extends PrimitiveType>(
 	// ((a === c) === true) => (a === c)
 	if (leftExpression._type === "Comparison" && isConstant(rightExpression) && rightExpression.value === true) {
 		return leftExpression;
+	} else if (rightExpression._type === "Comparison" && isConstant(leftExpression) && leftExpression.value === true) {
+		// (true === (a === c)) => (a === c)
+		return rightExpression;
 	} else if (leftExpression._type === "Comparison" && isConstant(rightExpression) && rightExpression.value === true) {
 		// ((a === c) === false) => !(a === c)
 		return not(leftExpression);
@@ -1500,6 +1522,7 @@ export function transformRecursively<T extends PrimitiveType | unknown>(
 			break;
 		case "DefaultBinding":
 		case "Ref":
+		case "Length":
 		case "Binding":
 		case "Constant":
 			// Do nothing
@@ -1513,6 +1536,135 @@ export function transformRecursively<T extends PrimitiveType | unknown>(
 
 export type BindingExpression<T> = T | string | undefined;
 
+const needParenthesis = function<T extends PrimitiveType>(expr: ExpressionOrPrimitive<T>): boolean {
+	return !isConstant(expr) && !isBinding(expr) && isExpression(expr) && expr._type !== "IfElse" && expr._type !== "Function";
+};
+
+/**
+ * Compiles a constant object to a string.
+ * @param expr
+ * @param isNullable
+ * @returns {string} The compiled string
+ */
+function compileConstantObject<T>(expr: ConstantExpression<object>, isNullable = false) {
+	if (isNullable && Object.keys(expr.value).length === 0) {
+		return "";
+	}
+	// Objects
+	const o = expr.value as PlainExpressionObject;
+	const properties: string[] = [];
+	Object.keys(o).forEach(key => {
+		const value = o[key];
+		const childResult = compileBinding(value, true, false, true);
+		if (childResult && childResult.length > 0) {
+			properties.push(`${key}: ${childResult}`);
+		}
+	});
+	return `{${properties.join(", ")}}`;
+}
+
+/**
+ * Compiles a Constant Binding Expression.
+ * @param expr
+ * @param embeddedInBinding
+ * @param isNullable
+ * @returns {string} The compiled string
+ */
+function compileConstant<T extends PrimitiveType>(expr: ConstantExpression<T>, embeddedInBinding: boolean, isNullable = false) {
+	if (expr.value === null) {
+		return "null";
+	}
+	if (expr.value === undefined) {
+		return "undefined";
+	}
+	if (typeof expr.value === "object") {
+		if (Array.isArray(expr.value)) {
+			const entries = expr.value.map(expression => compileBinding(expression, true));
+			return `[${entries.join(", ")}]`;
+		} else {
+			return compileConstantObject(expr as ConstantExpression<object>, isNullable);
+		}
+	}
+
+	if (embeddedInBinding) {
+		switch (typeof expr.value) {
+			case "number":
+			case "bigint":
+			case "boolean":
+				return expr.value.toString();
+			case "string":
+				return `'${escapeXmlAttribute(expr.value.toString())}'`;
+			default:
+				return "";
+		}
+	} else {
+		return expr.value.toString();
+	}
+}
+
+/**
+ * Generates the binding string for a Binding expression.
+ *
+ * @param expressionForBinding The expression to compile
+ * @param embeddedInBinding Whether the expression to compile is embedded into another expression
+ * @param embeddedSeparator The binding value evaluator ($ or % depending on whether we want to force the type or not)
+ * @returns {BindingExpression<T>} The corresponding expression binding
+ */
+function compileBindingForBinding<T extends PrimitiveType>(
+	expressionForBinding: BindingExpressionExpression<T> | DefaultBindingExpressionExpression<T>,
+	embeddedInBinding: boolean,
+	embeddedSeparator: string
+) {
+	if (
+		expressionForBinding.type ||
+		expressionForBinding.parameters ||
+		expressionForBinding.targetType ||
+		expressionForBinding.formatOptions ||
+		expressionForBinding.constraints
+	) {
+		// This is now a complex binding definition, let's prepare for it
+		const complexBindingDefinition = {
+			path: `${expressionForBinding.modelName ? expressionForBinding.modelName + ">" : ""}${expressionForBinding.path}`,
+			type: expressionForBinding.type,
+			targetType: expressionForBinding.targetType,
+			parameters: expressionForBinding.parameters,
+			formatOptions: expressionForBinding.formatOptions,
+			constraints: expressionForBinding.constraints
+		};
+		let outBinding = compileBinding(complexBindingDefinition);
+		if (embeddedInBinding) {
+			outBinding = `${embeddedSeparator}` + outBinding;
+		}
+		return outBinding;
+	} else if (embeddedInBinding) {
+		return `${embeddedSeparator}{${expressionForBinding.modelName ? expressionForBinding.modelName + ">" : ""}${
+			expressionForBinding.path
+		}}`;
+	} else {
+		return `{${expressionForBinding.modelName ? expressionForBinding.modelName + ">" : ""}${expressionForBinding.path}}`;
+	}
+}
+
+/**
+ * Wrap the compiled binding string as required dependening on its context.
+ *
+ * @param expression The compiled expression
+ * @param embeddedInBinding True if the compiled expression is to be embedded in a binding
+ * @param parenthesisRequired True if the embedded binding needs to be wrapped in parethesis so that it is evaluated as one
+ * @returns {BindingExpression<string>} Finalized compiled expression
+ */
+function wrapBindingExpression(expression: string, embeddedInBinding: boolean, parenthesisRequired = false): BindingExpression<string> {
+	if (embeddedInBinding) {
+		if (parenthesisRequired) {
+			return `(${expression})`;
+		} else {
+			return expression;
+		}
+	} else {
+		return `{= ${expression}}`;
+	}
+}
+
 /**
  * Compile an expression into an expression binding.
  *
@@ -1520,12 +1672,14 @@ export type BindingExpression<T> = T | string | undefined;
  * @param expression The expression to compile
  * @param embeddedInBinding Whether the expression to compile is embedded into another expression
  * @param keepTargetType Keep the target type of the embedded bindings instead of casting them to any
+ * @param isNullable Whether binding expression can resolve to empty string or not
  * @returns {BindingExpression<T>} The corresponding expression binding
  */
 export function compileBinding<T extends PrimitiveType>(
 	expression: ExpressionOrPrimitive<T>,
-	embeddedInBinding: boolean = false,
-	keepTargetType: boolean = false
+	embeddedInBinding = false,
+	keepTargetType = false,
+	isNullable = false
 ): BindingExpression<string> {
 	const expr = wrapPrimitive(expression);
 	const embeddedSeparator = keepTargetType ? "$" : "%";
@@ -1534,41 +1688,7 @@ export function compileBinding<T extends PrimitiveType>(
 		case "Unresolveable":
 			return undefined;
 		case "Constant":
-			if (expr.value === null) {
-				return "null";
-			}
-			if (expr.value === undefined) {
-				return "undefined";
-			}
-			if (typeof expr.value === "object") {
-				if (Array.isArray(expr.value)) {
-					const entries = expr.value.map(expression => compileBinding(expression, true));
-					return `[${entries.join(", ")}]`;
-				} else {
-					// Objects
-					const o = expr.value as PlainExpressionObject;
-					const properties = Object.keys(o).map(key => {
-						const value = o[key];
-						return `${key}: ${compileBinding(value, true)}`;
-					});
-					return `{${properties.join(", ")}}`;
-				}
-			}
-
-			if (embeddedInBinding) {
-				switch (typeof expr.value) {
-					case "number":
-					case "bigint":
-					case "boolean":
-						return expr.value.toString();
-					case "string":
-						return `'${escapeXmlAttribute(expr.value.toString())}'`;
-					default:
-						return "";
-				}
-			} else {
-				return expr.value.toString();
-			}
+			return compileConstant(expr, embeddedInBinding, isNullable);
 
 		case "Ref":
 			return expr.ref || "null";
@@ -1592,84 +1712,55 @@ export function compileBinding<T extends PrimitiveType>(
 			}
 		case "DefaultBinding":
 		case "Binding":
-			if (expr.type || expr.parameters || expr.targetType) {
-				let outBinding = "";
-				if (embeddedInBinding) {
-					outBinding += `${embeddedSeparator}`;
-				}
-				outBinding += `{path:'${expr.modelName ? `${expr.modelName}>` : ""}${expr.path}'`;
-				if (expr.type) {
-					outBinding += `, type: '${expr.type}'`;
-				}
-				if (expr.constraints && Object.keys(expr.constraints).length > 0) {
-					outBinding += `, constraints: ${compileBinding(expr.constraints)}`;
-				}
-				if (expr.formatOptions) {
-					outBinding += `, formatOptions: ${compileBinding(expr.formatOptions)}`;
-				}
-				if (expr.parameters && Object.keys(expr.parameters).length > 0) {
-					outBinding += `, parameters: ${compileBinding(expr.parameters)}`;
-				}
-				if (expr.targetType) {
-					outBinding += `, targetType: '${expr.targetType}'`;
-				}
-				outBinding += "}";
-				return outBinding;
-			} else {
-				if (embeddedInBinding) {
-					return `${embeddedSeparator}{${expr.modelName ? `${expr.modelName}>` : ""}${expr.path}}`;
-				} else {
-					return `{${expr.modelName ? `${expr.modelName}>` : ""}${expr.path}}`;
-				}
-			}
+			return compileBindingForBinding(expr, embeddedInBinding, embeddedSeparator);
 
 		case "Comparison":
-			const comparisonPart = `${compileBinding(expr.operand1, true)} ${expr.operator} ${compileBinding(expr.operand2, true)}`;
-			if (embeddedInBinding) {
-				return comparisonPart;
+			const isOperand1Complex = needParenthesis(expr.operand1);
+			const isOperand2Complex = needParenthesis(expr.operand2);
+			let comparisonPart = "";
+			if (isOperand1Complex) {
+				comparisonPart += "(";
+			}
+			comparisonPart += `${compileBinding(expr.operand1, true)}`;
+			if (isOperand1Complex) {
+				comparisonPart += ")";
+			}
+			comparisonPart += ` ${expr.operator} `;
+			if (isOperand2Complex) {
+				comparisonPart += "(";
 			}
-			return `{= ${comparisonPart}}`;
+			comparisonPart += `${compileBinding(expr.operand2, true)}`;
+			if (isOperand2Complex) {
+				comparisonPart += ")";
+			}
+			return wrapBindingExpression(comparisonPart, embeddedInBinding);
 
 		case "IfElse":
-			if (embeddedInBinding) {
-				return `(${compileBinding(expr.condition, true)} ? ${compileBinding(expr.onTrue, true)} : ${compileBinding(
-					expr.onFalse,
-					true
-				)})`;
-			} else {
-				return `{= ${compileBinding(expr.condition, true)} ? ${compileBinding(expr.onTrue, true)} : ${compileBinding(
-					expr.onFalse,
-					true
-				)}}`;
-			}
+			const ifElseExpression = `${compileBinding(expr.condition, true)} ? ${compileBinding(expr.onTrue, true)} : ${compileBinding(
+				expr.onFalse,
+				true
+			)}`;
+			return wrapBindingExpression(ifElseExpression, embeddedInBinding, true);
 
 		case "Set":
-			if (embeddedInBinding) {
-				return `(${expr.operands.map(expression => compileBinding(expression, true)).join(` ${expr.operator} `)})`;
-			} else {
-				return `{= (${expr.operands.map(expression => compileBinding(expression, true)).join(` ${expr.operator} `)})}`;
-			}
+			const setExpression = expr.operands.map(operand => compileBinding(operand, true)).join(` ${expr.operator} `);
+			return wrapBindingExpression(setExpression, embeddedInBinding, true);
 
 		case "Concat":
-			if (embeddedInBinding) {
-				return `${expr.expressions.map(expression => compileBinding(expression, true, true)).join(` + `)}`;
-			} else {
-				return `{= ${expr.expressions.map(expression => compileBinding(expression, true, true)).join(` + `)} }`;
-			}
+			const concatExpression = expr.expressions.map(nestedExpression => compileBinding(nestedExpression, true, true)).join(" + ");
+			return wrapBindingExpression(concatExpression, embeddedInBinding);
+
+		case "Length":
+			const lengthExpression = `${compileBinding(expr.bindingExpression, true)}.length`;
+			return wrapBindingExpression(lengthExpression, embeddedInBinding);
 
 		case "Not":
-			if (embeddedInBinding) {
-				return `!${compileBinding(expr.operand, true)}`;
-			} else {
-				return `{= !${compileBinding(expr.operand, true)}}`;
-			}
+			const notExpression = `!${compileBinding(expr.operand, true)}`;
+			return wrapBindingExpression(notExpression, embeddedInBinding);
 
 		case "Truthy":
-			if (embeddedInBinding) {
-				return `!!${compileBinding(expr.operand, true)}`;
-			} else {
-				return `{= !!${compileBinding(expr.operand, true)}}`;
-			}
+			const truthyExpression = `!!${compileBinding(expr.operand, true)}`;
+			return wrapBindingExpression(truthyExpression, embeddedInBinding);
 
 		case "Formatter":
 			if (expr.parameters.length === 1) {

package/src/sap/fe/core/helpers/DynamicAnnotationPathHelper.js

@@ -1,6 +1,6 @@
 /*!
  * SAPUI5
- * (c) Copyright 2009-2021 SAP SE. All rights reserved.
+ * (c) Copyright 2009-2022 SAP SE. All rights reserved.
  */
 sap.ui.define(["sap/ui/base/BindingParser"], function(BindingParser) {
 	"use strict";

package/src/sap/fe/core/helpers/EditState.js

@@ -1,6 +1,6 @@
 /*!
  * SAPUI5
- * (c) Copyright 2009-2021 SAP SE. All rights reserved.
+ * (c) Copyright 2009-2022 SAP SE. All rights reserved.
  */
 
 sap.ui.define(["sap/base/Log"], function(Log) {

package/src/sap/fe/core/helpers/ExcelFormatHelper.js

@@ -1,10 +1,9 @@
 /*!
  * SAPUI5
- * (c) Copyright 2009-2021 SAP SE. All rights reserved.
+ * (c) Copyright 2009-2022 SAP SE. All rights reserved.
  */
 sap.ui.define(["sap/ui/core/format/DateFormat"], function(DateFormat) {
 	"use strict";
-
 	var ExcelFormatHelper = {
 		/**
 		 * Method for converting JS Date format to Excel custom date format.
@@ -44,7 +43,6 @@ sap.ui.define(["sap/ui/core/format/DateFormat"], function(DateFormat) {
 			if (sJSTimeFormat && sJSTimeFormat.includes("a")) {
 				sJSTimeFormat = sJSTimeFormat.replace("a", "AM/PM");
 			}
-
 			return sJSTimeFormat;
 		}
 	};

package/src/sap/fe/core/helpers/FPMHelper.js

@@ -1,6 +1,6 @@
 /*!
  * SAPUI5
- * (c) Copyright 2009-2021 SAP SE. All rights reserved.
+ * (c) Copyright 2009-2022 SAP SE. All rights reserved.
  */
 sap.ui.define(["sap/fe/core/CommonUtils", "sap/base/util/ObjectPath"], function(CommonUtils, ObjectPath) {
 	"use strict";

package/src/sap/fe/core/helpers/KeepAliveHelper.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 && 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 && 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"]}