@sapui5/sap.fe.core 1.98.0 → 1.99.2

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

@@ -0,0 +1,81 @@
+const enumEditState = {
+	CLEAN: 0,
+	PROCESSED: 1,
+	DIRTY: 2
+};
+let currentEditState = enumEditState.CLEAN;
+
+export default {
+	/**
+	 * This sets the edit state as dirty, meaning bindings have to be refreshed.
+	 *
+	 * @function
+	 * @name sap.fe.core.helpers.EditState#setEditStateDirty
+	 * @memberof sap.fe.core.helpers.EditState
+	 *
+	 * @ui5-restricted
+	 * @final
+	 */
+	setEditStateDirty: function() {
+		currentEditState = enumEditState.DIRTY;
+	},
+
+	/**
+	 * This sets the edit state as processed, meaning is can be reset to clean after all bindings are refreshed.
+	 *
+	 * @function
+	 * @name sap.fe.core.helpers.EditState#setEditStateProcessed
+	 * @memberof sap.fe.core.helpers.EditState
+	 *
+	 * @ui5-restricted
+	 * @final
+	 */
+	setEditStateProcessed: function() {
+		currentEditState = enumEditState.PROCESSED;
+	},
+
+	/**
+	 * Resets the edit state to the initial state.
+	 *
+	 * @function
+	 * @name sap.fe.core.helpers.EditState#resetEditState
+	 * @memberof sap.fe.core.helpers.EditState
+	 *
+	 * @ui5-restricted
+	 * @final
+	 */
+	resetEditState: function() {
+		currentEditState = enumEditState.CLEAN;
+	},
+
+	/**
+	 * Returns true if the edit state is not clean, meaning bindings have to be refreshed
+	 *
+	 * @function
+	 * @name sap.fe.core.helpers.EditState#isEditStateDirty
+	 * @memberof sap.fe.core.helpers.EditState
+	 *
+	 * @ui5-restricted
+	 * @final
+	 */
+
+	isEditStateDirty: function() {
+		return currentEditState !== enumEditState.CLEAN;
+	},
+
+	/**
+	 * Cleans the edit state if it has been processed, i.e. bindings have been properly refreshed.
+	 *
+	 * @function
+	 * @name sap.fe.core.helpers.EditState#cleanProcessedEditState
+	 * @memberof sap.fe.core.helpers.EditState
+	 *
+	 * @ui5-restricted
+	 * @final
+	 */
+	cleanProcessedEditState: function() {
+		if (currentEditState === enumEditState.PROCESSED) {
+			currentEditState = enumEditState.CLEAN;
+		}
+	}
+};

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

@@ -1,50 +1,64 @@
 /*!
- * SAPUI5
- * (c) Copyright 2009-2022 SAP SE. All rights reserved.
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 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.
-		 *
-		 * @returns {string} Format for the Date column to be used on excel.
-		 */
-		getExcelDatefromJSDate: function() {
-			// Get date Format(pattern), which will be used for date format mapping between sapui5 and excel.
-			var sJSDateFormat = DateFormat.getDateInstance().oFormatOptions.pattern.toLowerCase();
-			if (sJSDateFormat) {
-				// Checking for the existence of single 'y' in the pattern.
-				var regex = /^[^y]*y[^y]*$/m;
-				if (regex.exec(sJSDateFormat)) {
-					sJSDateFormat = sJSDateFormat.replace("y", "yyyy");
-				}
-			}
-			return sJSDateFormat;
-		},
-		getExcelDateTimefromJSDateTime: function() {
-			// Get date Format(pattern), which will be used for date time format mapping between sapui5 and excel.
-			var sJSDateTimeFormat = DateFormat.getDateTimeInstance().oFormatOptions.pattern.toLowerCase();
-			if (sJSDateTimeFormat) {
-				// Checking for the existence of single 'y' in the pattern.
-				var regexYear = /^[^y]*y[^y]*$/m;
-				if (regexYear.exec(sJSDateTimeFormat)) {
-					sJSDateTimeFormat = sJSDateTimeFormat.replace("y", "yyyy");
-				}
-				if (sJSDateTimeFormat.includes("a")) {
-					sJSDateTimeFormat = sJSDateTimeFormat.replace("a", "AM/PM");
-				}
-			}
-			return sJSDateTimeFormat;
-		},
-		getExcelTimefromJSTime: function() {
-			// Get date Format(pattern), which will be used for date time format mapping between sapui5 and excel.
-			var sJSTimeFormat = DateFormat.getTimeInstance().oFormatOptions.pattern;
-			if (sJSTimeFormat && sJSTimeFormat.includes("a")) {
-				sJSTimeFormat = sJSTimeFormat.replace("a", "AM/PM");
-			}
-			return sJSTimeFormat;
-		}
-	};
-	return ExcelFormatHelper;
-});
+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.
+     *
+     * @returns {string} Format for the Date column to be used on excel.
+     */
+    getExcelDatefromJSDate: function () {
+      // Get date Format(pattern), which will be used for date format mapping between sapui5 and excel.
+      // UI5_ANY
+      var sJSDateFormat = DateFormat.getDateInstance().oFormatOptions.pattern.toLowerCase();
+
+      if (sJSDateFormat) {
+        // Checking for the existence of single 'y' in the pattern.
+        var regex = /^[^y]*y[^y]*$/m;
+
+        if (regex.exec(sJSDateFormat)) {
+          sJSDateFormat = sJSDateFormat.replace("y", "yyyy");
+        }
+      }
+
+      return sJSDateFormat;
+    },
+    getExcelDateTimefromJSDateTime: function () {
+      // Get date Format(pattern), which will be used for date time format mapping between sapui5 and excel.
+      // UI5_ANY
+      var sJSDateTimeFormat = DateFormat.getDateTimeInstance().oFormatOptions.pattern.toLowerCase();
+
+      if (sJSDateTimeFormat) {
+        // Checking for the existence of single 'y' in the pattern.
+        var regexYear = /^[^y]*y[^y]*$/m;
+
+        if (regexYear.exec(sJSDateTimeFormat)) {
+          sJSDateTimeFormat = sJSDateTimeFormat.replace("y", "yyyy");
+        }
+
+        if (sJSDateTimeFormat.includes("a")) {
+          sJSDateTimeFormat = sJSDateTimeFormat.replace("a", "AM/PM");
+        }
+      }
+
+      return sJSDateTimeFormat;
+    },
+    getExcelTimefromJSTime: function () {
+      // Get date Format(pattern), which will be used for date time format mapping between sapui5 and excel.
+      // UI5_ANY
+      var sJSTimeFormat = DateFormat.getTimeInstance().oFormatOptions.pattern;
+
+      if (sJSTimeFormat && sJSTimeFormat.includes("a")) {
+        sJSTimeFormat = sJSTimeFormat.replace("a", "AM/PM");
+      }
+
+      return sJSTimeFormat;
+    }
+  };
+  return ExcelFormatHelper;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,49 @@
+import DateFormat from "sap/ui/core/format/DateFormat";
+
+const ExcelFormatHelper = {
+	/**
+	 * Method for converting JS Date format to Excel custom date format.
+	 *
+	 * @returns {string} Format for the Date column to be used on excel.
+	 */
+	getExcelDatefromJSDate: function() {
+		// Get date Format(pattern), which will be used for date format mapping between sapui5 and excel.
+		// UI5_ANY
+		let sJSDateFormat = (DateFormat.getDateInstance() as any).oFormatOptions.pattern.toLowerCase();
+		if (sJSDateFormat) {
+			// Checking for the existence of single 'y' in the pattern.
+			const regex = /^[^y]*y[^y]*$/m;
+			if (regex.exec(sJSDateFormat)) {
+				sJSDateFormat = sJSDateFormat.replace("y", "yyyy");
+			}
+		}
+		return sJSDateFormat;
+	},
+	getExcelDateTimefromJSDateTime: function() {
+		// Get date Format(pattern), which will be used for date time format mapping between sapui5 and excel.
+		// UI5_ANY
+		let sJSDateTimeFormat = (DateFormat.getDateTimeInstance() as any).oFormatOptions.pattern.toLowerCase();
+		if (sJSDateTimeFormat) {
+			// Checking for the existence of single 'y' in the pattern.
+			const regexYear = /^[^y]*y[^y]*$/m;
+			if (regexYear.exec(sJSDateTimeFormat)) {
+				sJSDateTimeFormat = sJSDateTimeFormat.replace("y", "yyyy");
+			}
+			if (sJSDateTimeFormat.includes("a")) {
+				sJSDateTimeFormat = sJSDateTimeFormat.replace("a", "AM/PM");
+			}
+		}
+		return sJSDateTimeFormat;
+	},
+	getExcelTimefromJSTime: function() {
+		// Get date Format(pattern), which will be used for date time format mapping between sapui5 and excel.
+		// UI5_ANY
+		let sJSTimeFormat = (DateFormat.getTimeInstance() as any).oFormatOptions.pattern;
+		if (sJSTimeFormat && sJSTimeFormat.includes("a")) {
+			sJSTimeFormat = sJSTimeFormat.replace("a", "AM/PM");
+		}
+		return sJSTimeFormat;
+	}
+};
+
+export default ExcelFormatHelper;

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

@@ -1,63 +1,59 @@
 /*!
- * SAPUI5
- * (c) Copyright 2009-2022 SAP SE. All rights reserved.
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
  */
-sap.ui.define(["sap/fe/core/CommonUtils", "sap/base/util/ObjectPath"], function(CommonUtils, ObjectPath) {
-	"use strict";
-	var FPMHelper = {
-		actionWrapper: function(oEvent, sModule, sMethod, oParameters) {
-			return new Promise(function(resolve) {
-				var oSource = oEvent.getSource ? oEvent.getSource() : oEvent.oSource,
-					oView = CommonUtils.getTargetView(oSource),
-					oBindingContext = oSource.getBindingContext(),
-					oExtensionAPI,
-					aSelectedContexts;
+sap.ui.define(["sap/fe/core/CommonUtils", "sap/base/util/ObjectPath"], function (CommonUtils, ObjectPath) {
+  "use strict";
 
-				if (oParameters !== undefined) {
-					aSelectedContexts = oParameters.contexts || [];
-				} else if (oBindingContext !== undefined) {
-					aSelectedContexts = [oBindingContext];
-				} else {
-					aSelectedContexts = [];
-				}
+  var FPMHelper = {
+    actionWrapper: function (oEvent, sModule, sMethod, oParameters) {
+      return new Promise(function (resolve) {
+        var oSource = oEvent.getSource ? oEvent.getSource() : oEvent.oSource,
+            oView = CommonUtils.getTargetView(oSource),
+            oBindingContext = oSource.getBindingContext();
+        var oExtensionAPI;
+        var aSelectedContexts;
 
-				if (
-					oView.getControllerName() === "sap.fe.templates.ObjectPage.ObjectPageController" ||
-					oView.getControllerName() === "sap.fe.templates.ListReport.ListReportController"
-				) {
-					oExtensionAPI = oView.getController().getExtensionAPI();
-				}
+        if (oParameters !== undefined) {
+          aSelectedContexts = oParameters.contexts || [];
+        } else if (oBindingContext !== undefined) {
+          aSelectedContexts = [oBindingContext];
+        } else {
+          aSelectedContexts = [];
+        }
 
-				if (sModule.startsWith("/extension/")) {
-					var fnTarget = ObjectPath.get(sModule.replace(/\//g, ".").substr(1), oExtensionAPI);
-					resolve(fnTarget[sMethod](oBindingContext, aSelectedContexts));
-				} else {
-					sap.ui.require([sModule], function(module) {
-						// - we bind the action to the extensionAPI of the controller so it has the same scope as a custom section
-						// - we provide the context as API, maybe if needed further properties
-						resolve(module[sMethod].bind(oExtensionAPI)(oBindingContext, aSelectedContexts));
-					});
-				}
-			});
-		},
-		validationWrapper: function(sModule, sMethod, oValidationContexts, oView, oBindingContext) {
-			return new Promise(function(resolve) {
-				var oExtensionAPI;
+        if (oView.getControllerName() === "sap.fe.templates.ObjectPage.ObjectPageController" || oView.getControllerName() === "sap.fe.templates.ListReport.ListReportController") {
+          oExtensionAPI = oView.getController().getExtensionAPI();
+        }
 
-				if (
-					oView.getControllerName() === "sap.fe.templates.ObjectPage.ObjectPageController" ||
-					oView.getControllerName() === "sap.fe.templates.ListReport.ListReportController"
-				) {
-					oExtensionAPI = oView.getController().getExtensionAPI();
-				}
+        if (sModule.startsWith("/extension/")) {
+          var fnTarget = ObjectPath.get(sModule.replace(/\//g, ".").substr(1), oExtensionAPI);
+          resolve(fnTarget[sMethod](oBindingContext, aSelectedContexts));
+        } else {
+          sap.ui.require([sModule], function (module) {
+            // - we bind the action to the extensionAPI of the controller so it has the same scope as a custom section
+            // - we provide the context as API, maybe if needed further properties
+            resolve(module[sMethod].bind(oExtensionAPI)(oBindingContext, aSelectedContexts));
+          });
+        }
+      });
+    },
+    validationWrapper: function (sModule, sMethod, oValidationContexts, oView, oBindingContext) {
+      return new Promise(function (resolve) {
+        var oExtensionAPI;
 
-				sap.ui.require([sModule], function(module) {
-					// - we bind the action to the extensionAPI of the controller so it has the same scope as a custom section
-					// - we provide the context as API, maybe if needed further properties
-					resolve(module[sMethod].bind(oExtensionAPI)(oBindingContext, oValidationContexts));
-				});
-			});
-		}
-	};
-	return FPMHelper;
-});
+        if (oView.getControllerName() === "sap.fe.templates.ObjectPage.ObjectPageController" || oView.getControllerName() === "sap.fe.templates.ListReport.ListReportController") {
+          oExtensionAPI = oView.getController().getExtensionAPI();
+        }
+
+        sap.ui.require([sModule], function (module) {
+          // - we bind the action to the extensionAPI of the controller so it has the same scope as a custom section
+          // - we provide the context as API, maybe if needed further properties
+          resolve(module[sMethod].bind(oExtensionAPI)(oBindingContext, oValidationContexts));
+        });
+      });
+    }
+  };
+  return FPMHelper;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,62 @@
+import { ExtensionAPI } from "sap/fe/core";
+import CommonUtils from "sap/fe/core/CommonUtils";
+import ObjectPath from "sap/base/util/ObjectPath";
+import Context from "sap/ui/model/Context";
+
+const FPMHelper = {
+	actionWrapper: function(oEvent: any, sModule: any, sMethod: any, oParameters: any) {
+		return new Promise(function(resolve: (value: any) => void) {
+			const oSource = oEvent.getSource ? oEvent.getSource() : oEvent.oSource,
+				oView = CommonUtils.getTargetView(oSource),
+				oBindingContext = oSource.getBindingContext();
+			let oExtensionAPI: ExtensionAPI | undefined;
+			let aSelectedContexts: Context[];
+
+			if (oParameters !== undefined) {
+				aSelectedContexts = oParameters.contexts || [];
+			} else if (oBindingContext !== undefined) {
+				aSelectedContexts = [oBindingContext];
+			} else {
+				aSelectedContexts = [];
+			}
+
+			if (
+				oView.getControllerName() === "sap.fe.templates.ObjectPage.ObjectPageController" ||
+				oView.getControllerName() === "sap.fe.templates.ListReport.ListReportController"
+			) {
+				oExtensionAPI = oView.getController().getExtensionAPI();
+			}
+
+			if (sModule.startsWith("/extension/")) {
+				const fnTarget = ObjectPath.get(sModule.replace(/\//g, ".").substr(1), oExtensionAPI);
+				resolve(fnTarget[sMethod](oBindingContext, aSelectedContexts));
+			} else {
+				sap.ui.require([sModule], function(module: any) {
+					// - we bind the action to the extensionAPI of the controller so it has the same scope as a custom section
+					// - we provide the context as API, maybe if needed further properties
+					resolve(module[sMethod].bind(oExtensionAPI)(oBindingContext, aSelectedContexts));
+				});
+			}
+		});
+	},
+	validationWrapper: function(sModule: any, sMethod: any, oValidationContexts: any, oView: any, oBindingContext: any) {
+		return new Promise(function(resolve: (value: any) => void) {
+			let oExtensionAPI: ExtensionAPI;
+
+			if (
+				oView.getControllerName() === "sap.fe.templates.ObjectPage.ObjectPageController" ||
+				oView.getControllerName() === "sap.fe.templates.ListReport.ListReportController"
+			) {
+				oExtensionAPI = oView.getController().getExtensionAPI();
+			}
+
+			sap.ui.require([sModule], function(module: any) {
+				// - we bind the action to the extensionAPI of the controller so it has the same scope as a custom section
+				// - we provide the context as API, maybe if needed further properties
+				resolve(module[sMethod].bind(oExtensionAPI)(oBindingContext, oValidationContexts));
+			});
+		});
+	}
+};
+
+export default FPMHelper;

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

@@ -2,16 +2,15 @@
  * 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) {
+sap.ui.define(["sap/base/Log", "sap/fe/core/helpers/KeepAliveRefreshTypes", "./ModelHelper"], function (Log, KeepAliveRefreshTypes, ModelHelper) {
   "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 entitySetPath = ModelHelper.getEntitySetPath(entitySetPathToUse);
     var entitySet = entitySetPath.indexOf("$NavigationPropertyBinding") > -1 && metaModel.getObject(entitySetPath);
     return entitySet ? "/" + entitySet : entitySetPathToUse;
   };
@@ -208,4 +207,4 @@ sap.ui.define(["sap/base/Log", "sap/fe/core/helpers/ModelHelper", "sap/fe/core/h
   };
   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"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["KeepAliveHelper.ts"],"names":["_fnSimplifyEntitySetPath","metaModel","entitySetPathToUse","entitySetPath","ModelHelper","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/Control\";\nimport View from \"sap/ui/core/mvc/View\";\nimport Log from \"sap/base/Log\";\nimport ODataMetaModel from \"sap/ui/model/odata/v4/ODataMetaModel\";\nimport { BaseManifestSettings } from \"sap/fe/core/converters/ManifestSettings\";\nimport JSONModel from \"sap/ui/model/json/JSONModel\";\nimport {\n\tRefreshStrategyType,\n\tSORefreshStrategy,\n\tRefreshStrategies,\n\tPATH_TO_STORE,\n\tSOAction\n} from \"sap/fe/core/helpers/KeepAliveRefreshTypes\";\nimport ModelHelper, { InternalModelContext } from \"./ModelHelper\";\n\n// Private functions - start\nconst _fnSimplifyEntitySetPath = function(metaModel: ODataMetaModel, entitySetPathToUse: string): string {\n\tconst entitySetPath = ModelHelper.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\") as InternalModelContext;\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"]}

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

@@ -1,10 +1,9 @@
-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 Control from "sap/ui/core/Control";
+import View from "sap/ui/core/mvc/View";
+import Log from "sap/base/Log";
+import ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
 import { BaseManifestSettings } from "sap/fe/core/converters/ManifestSettings";
-import { JSONModel } from "sap/ui/model/json";
+import JSONModel from "sap/ui/model/json/JSONModel";
 import {
 	RefreshStrategyType,
 	SORefreshStrategy,
@@ -12,10 +11,11 @@ import {
 	PATH_TO_STORE,
 	SOAction
 } from "sap/fe/core/helpers/KeepAliveRefreshTypes";
+import ModelHelper, { InternalModelContext } from "./ModelHelper";
 
 // Private functions - start
 const _fnSimplifyEntitySetPath = function(metaModel: ODataMetaModel, entitySetPathToUse: string): string {
-	const entitySetPath = getEntitySetPath(entitySetPathToUse);
+	const entitySetPath = ModelHelper.getEntitySetPath(entitySetPathToUse);
 	const entitySet = entitySetPath.indexOf("$NavigationPropertyBinding") > -1 && metaModel.getObject(entitySetPath);
 	return entitySet ? "/" + entitySet : entitySetPathToUse;
 };
@@ -149,7 +149,7 @@ const storeControlRefreshStrategyForHash = function(control: Control, hash: SOAc
 				hash?.semanticObject,
 				hash?.action
 			);
-			(internalModel as JSONModel<{}>).setProperty(PATH_TO_STORE, refreshStrategy);
+			(internalModel as JSONModel).setProperty(PATH_TO_STORE, refreshStrategy);
 		}
 	}
 };
@@ -161,7 +161,7 @@ const storeControlRefreshStrategyForHash = function(control: Control, hash: SOAc
  * @returns {object} A promise after view refresh and restore are triggered
  */
 const restoreView = function(view: View): Promise<any> {
-	const internalModelContext = view.getBindingContext("internal");
+	const internalModelContext = view.getBindingContext("internal") as InternalModelContext;
 	const controller = view.getController();
 	const viewState = (controller as any)?.viewState;
 	let refreshBindings = Promise.resolve();