@ui5/task-adaptation 1.0.8 → 1.0.11

package/dist/bundle.js

@@ -1,4 +1,6 @@
-var window = {};'use strict';
+//1.99.0
+var window = {};
+'use strict';
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
@@ -34,6 +36,9 @@ Change.prototype.getChangeType = function () {
     return this._oDefinition.changeType;
   }
 };
+Change.prototype.getLayer = function () {
+  return this._oDefinition.layer;
+};
 Change.prototype.getContent = function () {
   return this._oDefinition.content;
 };
@@ -52,7 +57,7 @@ var Applier = {
   applyChanges: function (oUpdatedManifest, aAppDescriptorChanges, mStrategy) {
     return mStrategy.registry().then(function (Registry) {
       var aChangeHandlerPromises = aAppDescriptorChanges.map(function (oChange) {
-        return Registry[oChange.getChangeType()];
+        return Registry[oChange.getChangeType()] && Registry[oChange.getChangeType()]();
       });
       return Promise.all(aChangeHandlerPromises);
     }).then(function (aChangeHandlers) {
@@ -154,13 +159,13 @@ function setPropValueByPath(oEntityProp, oRoot) {
   }
   ObjectPath.set(aPath, oEntityProp.propertyValue, oRoot);
 }
-function changePropertyValueByPath (oChanges, oRootPath) {
-  if (Array.isArray(oChanges)) {
-    oChanges.forEach(function (oEntityProp) {
+function changePropertyValueByPath (vChanges, oRootPath) {
+  if (Array.isArray(vChanges)) {
+    vChanges.forEach(function (oEntityProp) {
       setPropValueByPath(oEntityProp, oRootPath);
     });
   } else {
-    setPropValueByPath(oChanges, oRootPath);
+    setPropValueByPath(vChanges, oRootPath);
   }
 }
 
@@ -168,50 +173,33 @@ var fnValues = function values(mObject) {
   if (typeof mObject === "undefined" || mObject === null || mObject !== mObject) {
     return [];
   }
-  if (typeof Object.values === "function") {
-    return Object.values(mObject);
-  }
-  if (typeof mObject === "string") {
-    return mObject.split("");
-  }
-  if (typeof mObject !== "object") {
-    return [];
-  }
-  return Object.keys(mObject).map(function (vValue) {
-    return mObject[vValue];
-  });
+  return Object.values(mObject);
 };
 
-function equals(a, b) {
-  return a === b || a !== a && b !== b;
-}
 var fnIncludes = function (vCollection, vValue, iFromIndex) {
   if (typeof iFromIndex !== "number") {
     iFromIndex = 0;
   }
-  if (Array.isArray(vCollection)) {
-    if (typeof vCollection.includes === "function") {
-      return vCollection.includes(vValue, iFromIndex);
+  if (Array.isArray(vCollection) || typeof vCollection === "string") {
+    if (iFromIndex < 0) {
+      iFromIndex = vCollection.length + iFromIndex < 0 ? 0 : vCollection.length + iFromIndex;
     }
-    iFromIndex = iFromIndex < 0 ? iFromIndex + vCollection.length : iFromIndex;
-    iFromIndex = iFromIndex < 0 ? 0 : iFromIndex;
-    for (var i = iFromIndex; i < vCollection.length; i++) {
-      if (equals(vCollection[i], vValue)) {
-        return true;
-      }
-    }
-    return false;
-  } else if (typeof vCollection === "string") {
-    iFromIndex = iFromIndex < 0 ? vCollection.length + iFromIndex : iFromIndex;
-    if (typeof vCollection.includes === "function") {
-      return vCollection.includes(vValue, iFromIndex);
-    }
-    return vCollection.indexOf(vValue, iFromIndex) !== -1;
+    return vCollection.includes(vValue, iFromIndex);
   } else {
     return fnIncludes(fnValues(vCollection), vValue, iFromIndex);
   }
 };
 
+var Layer = {
+  USER: "USER",
+  PUBLIC: "PUBLIC",
+  CUSTOMER: "CUSTOMER",
+  CUSTOMER_BASE: "CUSTOMER_BASE",
+  PARTNER: "PARTNER",
+  VENDOR: "VENDOR",
+  BASE: "BASE"
+};
+
 function checkChange(oEntityPropertyChange, aSupportedProperties, aSupportedOperations) {
   if (Array.isArray(oEntityPropertyChange)) {
     oEntityPropertyChange.forEach(function (change) {
@@ -238,7 +226,7 @@ function formatEntityCheck(oChangeEntity, aSupportedProperties, aSupportedOperat
     throw new Error("Operation " + oChangeEntity.operation + " is not supported. The supported 'operation' is " + aSupportedOperations.join("|"));
   }
 }
-function checkChangesConsistency (oChange, aSupportedProperties, aSupportedOperations) {
+function checkEntityPropertyChange(oChange, aSupportedProperties, aSupportedOperations) {
   var id = Object.keys(oChange).filter(function (key) {
     return key.endsWith("Id");
   }).shift();
@@ -250,6 +238,39 @@ function checkChangesConsistency (oChange, aSupportedProperties, aSupportedOpera
   }
   checkChange(oChange.entityPropertyChange, aSupportedProperties, aSupportedOperations);
 }
+var layer_prefixes = {};
+layer_prefixes[Layer.CUSTOMER] = "customer.";
+layer_prefixes[Layer.CUSTOMER_BASE] = "customer.";
+layer_prefixes[Layer.PARTNER] = "partner.";
+layer_prefixes[Layer.VENDOR] = null;
+function checkIdNamespaceCompliance(sId, oChange) {
+  var sLayer = oChange.getLayer();
+  if (!sLayer) {
+    throw new Error("Mandatory layer parameter is not provided.");
+  }
+  var sPrefix = getNamespacePrefixForLayer(sLayer);
+  if (sPrefix === null) {
+    Object.keys(layer_prefixes).forEach(function (sKey) {
+      if (layer_prefixes[sKey] && sId.startsWith(layer_prefixes[sKey])) {
+        throw new Error("Id " + sId + " must not start with reserved " + layer_prefixes[sKey]);
+      }
+    });
+  } else if (!sId.startsWith(sPrefix)) {
+    throw new Error("Id " + sId + " must start with " + sPrefix);
+  }
+}
+function getNamespacePrefixForLayer(sLayer) {
+  var sPrefix = layer_prefixes[sLayer];
+  if (sPrefix === undefined) {
+    throw new Error("Layer " + sLayer + " not supported.");
+  }
+  return sPrefix;
+}
+var DescriptorChangeCheck = {
+  checkEntityPropertyChange: checkEntityPropertyChange,
+  checkIdNamespaceCompliance: checkIdNamespaceCompliance,
+  getNamespacePrefixForLayer: getNamespacePrefixForLayer
+};
 
 var SUPPORTED_OPERATIONS$1 = ["UPDATE", "UPSERT"];
 var SUPPORTED_PROPERTIES$1 = ["uri", "settings/maxAge"];
@@ -257,7 +278,7 @@ var ChangeDataSouce = {
   applyChange: function (oManifest, oChange) {
     var oDataSources = oManifest["sap.app"].dataSources;
     var oChangeContent = oChange.getContent();
-    checkChangesConsistency(oChangeContent, SUPPORTED_PROPERTIES$1, SUPPORTED_OPERATIONS$1);
+    DescriptorChangeCheck.checkEntityPropertyChange(oChangeContent, SUPPORTED_PROPERTIES$1, SUPPORTED_OPERATIONS$1);
     if (oDataSources) {
       var oDataSource = oDataSources[oChangeContent.dataSourceId];
       if (oDataSource) {
@@ -536,12 +557,13 @@ function checkingAnnotationsInsertPosition(sChangeAnnotationsInsertPosition) {
     throw new Error("The defined insert position '" + sChangeAnnotationsInsertPosition + "' is not supported. The supported insert positions are: " + SUPPORTED_INSERT_POSITION.join("|"));
   }
 }
-function checkingAnnotationDataSource(oChangeDataSource, aChangeAnnotations) {
+function checkingAnnotationDataSource(oChangeDataSource, aChangeAnnotations, oChange) {
   if (oChangeDataSource) {
     if (Object.keys(oChangeDataSource).length === 0) {
       throw new Error("The 'dataSource' object is empty");
     }
     Object.keys(oChangeDataSource).forEach(function (sAnnotation) {
+      DescriptorChangeCheck.checkIdNamespaceCompliance(sAnnotation, oChange);
       if (!isAnnotationTypeOfOdataAnnotation(oChangeDataSource, sAnnotation)) {
         throw new Error("The dataSource annotation '" + sAnnotation + "' is type of '" + oChangeDataSource[sAnnotation].type + "'. Only dataSource annotations of type 'ODataAnnotation' is supported");
       }
@@ -593,7 +615,7 @@ var AddAnnotationsToOData = {
     checkingDataSourceId(oManifest["sap.app"].dataSources, sChangeDataSourceId);
     checkingAnnotationArray(aChangeAnnotations);
     checkingAnnotationsInsertPosition(sChangeAnnotationsInsertPosition);
-    checkingAnnotationDataSource(oChangeDataSource, aChangeAnnotations);
+    checkingAnnotationDataSource(oChangeDataSource, aChangeAnnotations, oChange);
     postChecks(oManifest["sap.app"]["dataSources"], oChangeDataSource, aChangeAnnotations);
     merge(oManifest["sap.app"]["dataSources"], sChangeDataSourceId, aChangeAnnotations, sChangeAnnotationsInsertPosition, oChangeDataSource);
     return oManifest;
@@ -601,12 +623,12 @@ var AddAnnotationsToOData = {
 };
 
 var SUPPORTED_OPERATIONS = ["UPDATE", "UPSERT"];
-var SUPPORTED_PROPERTIES = ["title", "subtitle", "icon"];
+var SUPPORTED_PROPERTIES = ["title", "subTitle", "icon"];
 var ChangeInbound = {
   applyChange: function (oManifest, oChange) {
     var oCrossNavigation = oManifest["sap.app"].crossNavigation;
     var oChangeContent = oChange.getContent();
-    checkChangesConsistency(oChangeContent, SUPPORTED_PROPERTIES, SUPPORTED_OPERATIONS);
+    DescriptorChangeCheck.checkEntityPropertyChange(oChangeContent, SUPPORTED_PROPERTIES, SUPPORTED_OPERATIONS);
     if (oCrossNavigation && oCrossNavigation.inbounds) {
       var oInbound = oCrossNavigation.inbounds[oChangeContent.inboundId];
       if (oInbound) {
@@ -621,6 +643,19 @@ var ChangeInbound = {
   }
 };
 
+var SetAbstract = {
+  applyChange: function (oManifest, oChange) {
+    if (!oChange.getContent().hasOwnProperty("abstract")) {
+      throw new Error("No abstract in change content provided");
+    }
+    if (oChange.getContent().abstract !== false) {
+      throw new Error("The current change value of property abstract is '" + oChange.getContent().abstract + "'. Only allowed value for property abstract is boolean 'false'");
+    }
+    ObjectPath.set(["sap.fiori", "abstract"], oChange.getContent().abstract, oManifest);
+    return oManifest;
+  }
+};
+
 function _mergeExistingLibrary(oManifestLib, oChangeLib) {
   var oUpdatedLibrary = {};
   if (oChangeLib.minVersion) {
@@ -704,24 +739,835 @@ var DeleteCard = {
   }
 };
 
+var fnNow = !(typeof window != "undefined" && window.performance && performance.now && performance.timing) ? Date.now : (function () {
+  var iNavigationStart = performance.timing.navigationStart;
+  return function perfnow() {
+    return iNavigationStart + performance.now();
+  };
+})();
+
+var Log = {};
+Log.Level = {
+  NONE: -1,
+  FATAL: 0,
+  ERROR: 1,
+  WARNING: 2,
+  INFO: 3,
+  DEBUG: 4,
+  TRACE: 5,
+  ALL: 5 + 1
+};
+var sDefaultComponent, aLog = [], mMaxLevel = {
+  "": Log.Level.ERROR
+}, iLogEntriesLimit = 3000, oListener = null, bLogSupportInfo = false;
+function pad0(i, w) {
+  return ("000" + String(i)).slice(-w);
+}
+function level(sComponent) {
+  return !sComponent || isNaN(mMaxLevel[sComponent]) ? mMaxLevel[""] : mMaxLevel[sComponent];
+}
+function discardLogEntries() {
+  var iLogLength = aLog.length;
+  if (iLogLength) {
+    var iEntriesToKeep = Math.min(iLogLength, Math.floor(iLogEntriesLimit * 0.7));
+    if (oListener) {
+      oListener.onDiscardLogEntries(aLog.slice(0, iLogLength - iEntriesToKeep));
+    }
+    if (iEntriesToKeep) {
+      aLog = aLog.slice(-iEntriesToKeep, iLogLength);
+    } else {
+      aLog = [];
+    }
+  }
+}
+function getLogEntryListenerInstance() {
+  if (!oListener) {
+    oListener = {
+      listeners: [],
+      onLogEntry: function (oLogEntry) {
+        for (var i = 0; i < oListener.listeners.length; i++) {
+          if (oListener.listeners[i].onLogEntry) {
+            oListener.listeners[i].onLogEntry(oLogEntry);
+          }
+        }
+      },
+      onDiscardLogEntries: function (aDiscardedLogEntries) {
+        for (var i = 0; i < oListener.listeners.length; i++) {
+          if (oListener.listeners[i].onDiscardLogEntries) {
+            oListener.listeners[i].onDiscardLogEntries(aDiscardedLogEntries);
+          }
+        }
+      },
+      attach: function (oLog, oLstnr) {
+        if (oLstnr) {
+          oListener.listeners.push(oLstnr);
+          if (oLstnr.onAttachToLog) {
+            oLstnr.onAttachToLog(oLog);
+          }
+        }
+      },
+      detach: function (oLog, oLstnr) {
+        for (var i = 0; i < oListener.listeners.length; i++) {
+          if (oListener.listeners[i] === oLstnr) {
+            if (oLstnr.onDetachFromLog) {
+              oLstnr.onDetachFromLog(oLog);
+            }
+            oListener.listeners.splice(i, 1);
+            return;
+          }
+        }
+      }
+    };
+  }
+  return oListener;
+}
+Log.fatal = function (sMessage, sDetails, sComponent, fnSupportInfo) {
+  log(Log.Level.FATAL, sMessage, sDetails, sComponent, fnSupportInfo);
+};
+Log.error = function (sMessage, sDetails, sComponent, fnSupportInfo) {
+  log(Log.Level.ERROR, sMessage, sDetails, sComponent, fnSupportInfo);
+};
+Log.warning = function (sMessage, sDetails, sComponent, fnSupportInfo) {
+  log(Log.Level.WARNING, sMessage, sDetails, sComponent, fnSupportInfo);
+};
+Log.info = function (sMessage, sDetails, sComponent, fnSupportInfo) {
+  log(Log.Level.INFO, sMessage, sDetails, sComponent, fnSupportInfo);
+};
+Log.debug = function (sMessage, sDetails, sComponent, fnSupportInfo) {
+  log(Log.Level.DEBUG, sMessage, sDetails, sComponent, fnSupportInfo);
+};
+Log.trace = function (sMessage, sDetails, sComponent, fnSupportInfo) {
+  log(Log.Level.TRACE, sMessage, sDetails, sComponent, fnSupportInfo);
+};
+Log.setLevel = function (iLogLevel, sComponent, _bDefault) {
+  sComponent = sComponent || sDefaultComponent || "";
+  if (!_bDefault || mMaxLevel[sComponent] == null) {
+    mMaxLevel[sComponent] = iLogLevel;
+    var sLogLevel;
+    Object.keys(Log.Level).forEach(function (sLevel) {
+      if (Log.Level[sLevel] === iLogLevel) {
+        sLogLevel = sLevel;
+      }
+    });
+    log(Log.Level.INFO, "Changing log level " + (sComponent ? "for '" + sComponent + "' " : "") + "to " + sLogLevel, "", "sap.base.log");
+  }
+};
+Log.getLevel = function (sComponent) {
+  return level(sComponent || sDefaultComponent);
+};
+Log.isLoggable = function (iLevel, sComponent) {
+  return (iLevel == null ? Log.Level.DEBUG : iLevel) <= level(sComponent || sDefaultComponent);
+};
+Log.logSupportInfo = function (bEnabled) {
+  bLogSupportInfo = bEnabled;
+};
+function log(iLevel, sMessage, sDetails, sComponent, fnSupportInfo) {
+  if (!fnSupportInfo && !sComponent && typeof sDetails === "function") {
+    fnSupportInfo = sDetails;
+    sDetails = "";
+  }
+  if (!fnSupportInfo && typeof sComponent === "function") {
+    fnSupportInfo = sComponent;
+    sComponent = "";
+  }
+  sComponent = sComponent || sDefaultComponent;
+  if (iLevel <= level(sComponent)) {
+    var fNow = fnNow(), oNow = new Date(fNow), iMicroSeconds = Math.floor((fNow - Math.floor(fNow)) * 1000), oLogEntry = {
+      time: pad0(oNow.getHours(), 2) + ":" + pad0(oNow.getMinutes(), 2) + ":" + pad0(oNow.getSeconds(), 2) + "." + pad0(oNow.getMilliseconds(), 3) + pad0(iMicroSeconds, 3),
+      date: pad0(oNow.getFullYear(), 4) + "-" + pad0(oNow.getMonth() + 1, 2) + "-" + pad0(oNow.getDate(), 2),
+      timestamp: fNow,
+      level: iLevel,
+      message: String(sMessage || ""),
+      details: String(sDetails || ""),
+      component: String(sComponent || "")
+    };
+    if (bLogSupportInfo && typeof fnSupportInfo === "function") {
+      oLogEntry.supportInfo = fnSupportInfo();
+    }
+    if (iLogEntriesLimit) {
+      if (aLog.length >= iLogEntriesLimit) {
+        discardLogEntries();
+      }
+      aLog.push(oLogEntry);
+    }
+    if (oListener) {
+      oListener.onLogEntry(oLogEntry);
+    }
+    if (console) {
+      var isDetailsError = sDetails instanceof Error, logText = oLogEntry.date + " " + oLogEntry.time + " " + oLogEntry.message + " - " + oLogEntry.details + " " + oLogEntry.component;
+      switch (iLevel) {
+        case Log.Level.FATAL:
+        case Log.Level.ERROR:
+          isDetailsError ? console.error(logText, "\n", sDetails) : console.error(logText);
+          break;
+        case Log.Level.WARNING:
+          isDetailsError ? console.warn(logText, "\n", sDetails) : console.warn(logText);
+          break;
+        case Log.Level.INFO:
+          if (console.info) {
+            isDetailsError ? console.info(logText, "\n", sDetails) : console.info(logText);
+          } else {
+            isDetailsError ? console.log(logText, "\n", sDetails) : console.log(logText);
+          }
+          break;
+        case Log.Level.DEBUG:
+          isDetailsError ? console.debug(logText, "\n", sDetails) : console.debug(logText);
+          break;
+        case Log.Level.TRACE:
+          isDetailsError ? console.trace(logText, "\n", sDetails) : console.trace(logText);
+          break;
+      }
+      if (console.info && oLogEntry.supportInfo) {
+        console.info(oLogEntry.supportInfo);
+      }
+    }
+    return oLogEntry;
+  }
+}
+Log.getLogEntries = function () {
+  return aLog.slice();
+};
+Log.getLogEntriesLimit = function () {
+  return iLogEntriesLimit;
+};
+Log.setLogEntriesLimit = function (iLimit) {
+  if (iLimit < 0) {
+    throw new Error("The log entries limit needs to be greater than or equal to 0!");
+  }
+  iLogEntriesLimit = iLimit;
+  if (aLog.length >= iLogEntriesLimit) {
+    discardLogEntries();
+  }
+};
+Log.addLogListener = function (oListener) {
+  getLogEntryListenerInstance().attach(this, oListener);
+};
+Log.removeLogListener = function (oListener) {
+  getLogEntryListenerInstance().detach(this, oListener);
+};
+function Logger(sComponent) {
+  this.fatal = function (msg, detail, comp, support) {
+    Log.fatal(msg, detail, comp || sComponent, support);
+    return this;
+  };
+  this.error = function (msg, detail, comp, support) {
+    Log.error(msg, detail, comp || sComponent, support);
+    return this;
+  };
+  this.warning = function (msg, detail, comp, support) {
+    Log.warning(msg, detail, comp || sComponent, support);
+    return this;
+  };
+  this.info = function (msg, detail, comp, support) {
+    Log.info(msg, detail, comp || sComponent, support);
+    return this;
+  };
+  this.debug = function (msg, detail, comp, support) {
+    Log.debug(msg, detail, comp || sComponent, support);
+    return this;
+  };
+  this.trace = function (msg, detail, comp, support) {
+    Log.trace(msg, detail, comp || sComponent, support);
+    return this;
+  };
+  this.setLevel = function (level, comp) {
+    Log.setLevel(level, comp || sComponent);
+    return this;
+  };
+  this.getLevel = function (comp) {
+    return Log.getLevel(comp || sComponent);
+  };
+  this.isLoggable = function (level, comp) {
+    return Log.isLoggable(level, comp || sComponent);
+  };
+}
+Log.getLogger = function (sComponent, iDefaultLogLevel) {
+  if (!isNaN(iDefaultLogLevel) && mMaxLevel[sComponent] == null) {
+    mMaxLevel[sComponent] = iDefaultLogLevel;
+  }
+  return new Logger(sComponent);
+};
+
+var fnAssert = function (bResult, vMessage) {
+  if (!bResult) {
+    var sMessage = typeof vMessage === "function" ? vMessage() : vMessage;
+    console.assert(bResult, sMessage);
+  }
+};
+
+var fnUniqueSort = function (aArray) {
+  fnAssert(Array.isArray(aArray), "uniqueSort: input parameter must be an Array");
+  var iLength = aArray.length;
+  if (iLength > 1) {
+    aArray.sort();
+    var j = 0;
+    for (var i = 1; i < iLength; i++) {
+      if (aArray.indexOf(aArray[i]) === i) {
+        aArray[++j] = aArray[i];
+      }
+    }
+    if (++j < iLength) {
+      aArray.splice(j, iLength - j);
+    }
+  }
+  return aArray;
+};
+
+var Metadata = function (sClassName, oClassInfo) {
+  fnAssert(typeof sClassName === "string" && sClassName, "Metadata: sClassName must be a non-empty string");
+  fnAssert(typeof oClassInfo === "object", "Metadata: oClassInfo must be empty or an object");
+  if (!oClassInfo || typeof oClassInfo.metadata !== "object") {
+    oClassInfo = {
+      metadata: oClassInfo || ({}),
+      constructor: ObjectPath.get(sClassName)
+    };
+    oClassInfo.metadata.__version = 1;
+  }
+  oClassInfo.metadata.__version = oClassInfo.metadata.__version || 2;
+  if (typeof oClassInfo.constructor !== "function") {
+    throw Error("constructor for class " + sClassName + " must have been declared before creating metadata for it");
+  }
+  this._sClassName = sClassName;
+  this._oClass = oClassInfo.constructor;
+  this.extend(oClassInfo);
+};
+Metadata.prototype.extend = function (oClassInfo) {
+  this.applySettings(oClassInfo);
+  this.afterApplySettings();
+};
+Metadata.prototype.applySettings = function (oClassInfo) {
+  var that = this, oStaticInfo = oClassInfo.metadata, oPrototype;
+  if (oStaticInfo.baseType) {
+    var oParentClass = ObjectPath.get(oStaticInfo.baseType);
+    if (typeof oParentClass !== "function") {
+      Log.fatal("base class '" + oStaticInfo.baseType + "' does not exist");
+    }
+    if (oParentClass.getMetadata) {
+      this._oParent = oParentClass.getMetadata();
+      fnAssert(oParentClass === oParentClass.getMetadata().getClass(), "Metadata: oParentClass must match the class in the parent metadata");
+    } else {
+      this._oParent = new Metadata(oStaticInfo.baseType, {});
+    }
+  } else {
+    this._oParent = undefined;
+  }
+  this._bAbstract = !!oStaticInfo["abstract"];
+  this._bFinal = !!oStaticInfo["final"];
+  this._sStereotype = oStaticInfo.stereotype || (this._oParent ? this._oParent._sStereotype : "object");
+  this._bDeprecated = !!oStaticInfo["deprecated"];
+  this._aInterfaces = oStaticInfo.interfaces || [];
+  this._aPublicMethods = oStaticInfo.publicMethods || [];
+  this._bInterfacesUnique = false;
+  oPrototype = this._oClass.prototype;
+  for (var n in oClassInfo) {
+    if (n !== "metadata" && n !== "constructor") {
+      oPrototype[n] = oClassInfo[n];
+      if (!n.match(/^_|^on|^init$|^exit$/)) {
+        that._aPublicMethods.push(n);
+      }
+    }
+  }
+};
+Metadata.prototype.afterApplySettings = function () {
+  if (this._oParent) {
+    this._aAllPublicMethods = this._oParent._aAllPublicMethods.concat(this._aPublicMethods);
+    this._bInterfacesUnique = false;
+  } else {
+    this._aAllPublicMethods = this._aPublicMethods;
+  }
+};
+Metadata.prototype.getStereotype = function () {
+  return this._sStereotype;
+};
+Metadata.prototype.getName = function () {
+  return this._sClassName;
+};
+Metadata.prototype.getClass = function () {
+  return this._oClass;
+};
+Metadata.prototype.getParent = function () {
+  return this._oParent;
+};
+Metadata.prototype._dedupInterfaces = function () {
+  if (!this._bInterfacesUnique) {
+    fnUniqueSort(this._aInterfaces);
+    fnUniqueSort(this._aPublicMethods);
+    fnUniqueSort(this._aAllPublicMethods);
+    this._bInterfacesUnique = true;
+  }
+};
+Metadata.prototype.getPublicMethods = function () {
+  this._dedupInterfaces();
+  return this._aPublicMethods;
+};
+Metadata.prototype.getAllPublicMethods = function () {
+  this._dedupInterfaces();
+  return this._aAllPublicMethods;
+};
+Metadata.prototype.getInterfaces = function () {
+  this._dedupInterfaces();
+  return this._aInterfaces;
+};
+Metadata.prototype.isInstanceOf = function (sInterface) {
+  if (this._oParent) {
+    if (this._oParent.isInstanceOf(sInterface)) {
+      return true;
+    }
+  }
+  var a = this._aInterfaces;
+  for (var i = 0, l = a.length; i < l; i++) {
+    if (a[i] === sInterface) {
+      return true;
+    }
+  }
+  return false;
+};
+Object.defineProperty(Metadata.prototype, "_mImplementedTypes", {
+  get: function () {
+    if (this === Metadata.prototype) {
+      throw new Error("sap.ui.base.Metadata: The '_mImplementedTypes' property must not be accessed on the prototype");
+    }
+    var result = Object.create(this._oParent ? this._oParent._mImplementedTypes : null);
+    result[this._sClassName] = true;
+    var aInterfaces = this._aInterfaces, i = aInterfaces.length;
+    while (i-- > 0) {
+      if (!result[aInterfaces[i]]) {
+        result[aInterfaces[i]] = true;
+      }
+    }
+    Object.defineProperty(this, "_mImplementedTypes", {
+      value: Object.freeze(result),
+      writable: false,
+      configurable: false
+    });
+    return result;
+  },
+  configurable: true
+});
+Metadata.prototype.isA = function (vTypeName) {
+  var mTypes = this._mImplementedTypes;
+  if (Array.isArray(vTypeName)) {
+    for (var i = 0; i < vTypeName.length; i++) {
+      if ((vTypeName[i] in mTypes)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  return (vTypeName in mTypes);
+};
+Metadata.prototype.isAbstract = function () {
+  return this._bAbstract;
+};
+Metadata.prototype.isFinal = function () {
+  return this._bFinal;
+};
+Metadata.prototype.isDeprecated = function () {
+  return this._bDeprecated;
+};
+Metadata.prototype.addPublicMethods = function (sMethod) {
+  var aNames = sMethod instanceof Array ? sMethod : arguments;
+  Array.prototype.push.apply(this._aPublicMethods, aNames);
+  Array.prototype.push.apply(this._aAllPublicMethods, aNames);
+  this._bInterfacesUnique = false;
+};
+Metadata.createClass = function (fnBaseClass, sClassName, oClassInfo, FNMetaImpl) {
+  if (typeof fnBaseClass === "string") {
+    FNMetaImpl = oClassInfo;
+    oClassInfo = sClassName;
+    sClassName = fnBaseClass;
+    fnBaseClass = null;
+  }
+  fnAssert(!fnBaseClass || typeof fnBaseClass === "function");
+  fnAssert(typeof sClassName === "string" && !!sClassName);
+  fnAssert(!oClassInfo || typeof oClassInfo === "object");
+  fnAssert(!FNMetaImpl || typeof FNMetaImpl === "function");
+  FNMetaImpl = FNMetaImpl || Metadata;
+  if (typeof FNMetaImpl.preprocessClassInfo === "function") {
+    oClassInfo = FNMetaImpl.preprocessClassInfo(oClassInfo);
+  }
+  oClassInfo = oClassInfo || ({});
+  oClassInfo.metadata = oClassInfo.metadata || ({});
+  if (!oClassInfo.hasOwnProperty("constructor")) {
+    oClassInfo.constructor = undefined;
+  }
+  var fnClass = oClassInfo.constructor;
+  fnAssert(!fnClass || typeof fnClass === "function");
+  if (fnBaseClass) {
+    if (!fnClass) {
+      if (oClassInfo.metadata.deprecated) {
+        fnClass = function () {
+          Log.warning("Usage of deprecated class: " + sClassName);
+          fnBaseClass.apply(this, arguments);
+        };
+      } else {
+        fnClass = function () {
+          fnBaseClass.apply(this, arguments);
+        };
+      }
+    }
+    fnClass.prototype = Object.create(fnBaseClass.prototype);
+    fnClass.prototype.constructor = fnClass;
+    oClassInfo.metadata.baseType = fnBaseClass.getMetadata().getName();
+  } else {
+    fnClass = fnClass || (function () {});
+    delete oClassInfo.metadata.baseType;
+  }
+  oClassInfo.constructor = fnClass;
+  ObjectPath.set(sClassName, fnClass);
+  var oMetadata = new FNMetaImpl(sClassName, oClassInfo);
+  fnClass.getMetadata = fnClass.prototype.getMetadata = function () {
+    return oMetadata;
+  };
+  if (!fnClass.getMetadata().isFinal()) {
+    fnClass.extend = function (sSCName, oSCClassInfo, fnSCMetaImpl) {
+      return Metadata.createClass(fnClass, sSCName, oSCClassInfo, fnSCMetaImpl || FNMetaImpl);
+    };
+  }
+  return fnClass;
+};
+
+var BaseObject = Metadata.createClass("sap.ui.base.Object", {
+  constructor: function () {
+    if (!(this instanceof BaseObject)) {
+      throw Error("Cannot instantiate object: \"new\" is missing!");
+    }
+  }
+});
+BaseObject.prototype.destroy = function () {};
+BaseObject.prototype.getInterface = function () {
+  var oInterface = new BaseObject._Interface(this, this.getMetadata().getAllPublicMethods());
+  this.getInterface = function () {
+    return oInterface;
+  };
+  return oInterface;
+};
+BaseObject.defineClass = function (sClassName, oStaticInfo, FNMetaImpl) {
+  var oMetadata = new (FNMetaImpl || Metadata)(sClassName, oStaticInfo);
+  var fnClass = oMetadata.getClass();
+  fnClass.getMetadata = fnClass.prototype.getMetadata = function () {
+    return oMetadata;
+  };
+  if (!oMetadata.isFinal()) {
+    fnClass.extend = function (sSCName, oSCClassInfo, fnSCMetaImpl) {
+      return Metadata.createClass(fnClass, sSCName, oSCClassInfo, fnSCMetaImpl || FNMetaImpl);
+    };
+  }
+  Log.debug("defined class '" + sClassName + "'" + (oMetadata.getParent() ? " as subclass of " + oMetadata.getParent().getName() : ""));
+  return oMetadata;
+};
+BaseObject.prototype.isA = function (vTypeName) {
+  return this.getMetadata().isA(vTypeName);
+};
+BaseObject.isA = function (oObject, vTypeName) {
+  return oObject instanceof BaseObject && oObject.isA(vTypeName);
+};
+BaseObject._Interface = function (oObject, aMethods, _bReturnFacade) {
+  if (!oObject) {
+    return oObject;
+  }
+  function fCreateDelegator(oObject, sMethodName) {
+    return function () {
+      var tmp = oObject[sMethodName].apply(oObject, arguments);
+      if (_bReturnFacade) {
+        return this;
+      } else {
+        return tmp instanceof BaseObject ? tmp.getInterface() : tmp;
+      }
+    };
+  }
+  if (!aMethods) {
+    return {};
+  }
+  var sMethodName;
+  for (var i = 0, ml = aMethods.length; i < ml; i++) {
+    sMethodName = aMethods[i];
+    if (!oObject[sMethodName] || typeof oObject[sMethodName] === "function") {
+      this[sMethodName] = fCreateDelegator(oObject, sMethodName);
+    }
+  }
+};
+
+var class2type = {};
+var hasOwn = class2type.hasOwnProperty;
+var toString = class2type.toString;
+var fnToString = hasOwn.toString;
+var ObjectFunctionString = fnToString.call(Object);
+var fnIsPlainObject = function (obj) {
+  var proto, Ctor;
+  if (!obj || toString.call(obj) !== "[object Object]") {
+    return false;
+  }
+  proto = Object.getPrototypeOf(obj);
+  if (!proto) {
+    return true;
+  }
+  Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
+};
+
+var oToken = Object.create(null);
+var fnMerge = function () {
+  var src, copyIsArray, copy, name, options, clone, target = arguments[2] || ({}), i = 3, length = arguments.length, deep = arguments[0] || false, skipToken = arguments[1] ? undefined : oToken;
+  if (typeof target !== "object" && typeof target !== "function") {
+    target = {};
+  }
+  for (; i < length; i++) {
+    if ((options = arguments[i]) != null) {
+      for (name in options) {
+        src = target[name];
+        copy = options[name];
+        if (name === "__proto__" || target === copy) {
+          continue;
+        }
+        if (deep && copy && (fnIsPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
+          if (copyIsArray) {
+            copyIsArray = false;
+            clone = src && Array.isArray(src) ? src : [];
+          } else {
+            clone = src && fnIsPlainObject(src) ? src : {};
+          }
+          target[name] = fnMerge(deep, arguments[1], clone, copy);
+        } else if (copy !== skipToken) {
+          target[name] = copy;
+        }
+      }
+    }
+  }
+  return target;
+};
+
+var fnExtend = function () {
+  var args = [false, true];
+  args.push.apply(args, arguments);
+  return fnMerge.apply(null, args);
+};
+
+var sFioriComponent = "FioriElements: ";
+function getMethods(sClassName, oLog) {
+  var sFullClassName = sFioriComponent + sClassName;
+  return {
+    Level: oLog.Level,
+    addLogListener: function (oListener) {
+      oLog.addLogListener(oListener);
+    },
+    getLogger: function () {
+      return oLog.getLogger(sFullClassName);
+    }
+  };
+}
+var FeLogger = BaseObject.extend("sap.suite.ui.generic.template.genericUtilities.FeLogger", {
+  constructor: function (sClassName) {
+    fnExtend(this, getMethods(sClassName, Log));
+  }
+});
+
+var oLogger$2 = new FeLogger("manifestMerger.MergerUil").getLogger();
+var mergerUtil = {
+  iterateAndFind: function iterateFind(oPages, sEntityKey, sPageComponent, sChildPageId, sParentKey) {
+    var oPageStructure;
+    if (Array.isArray(oPages)) {
+      throw new Error("Manifest should have sap.ui.generic.app.pages as Object structure and not array ");
+    }
+    for (var sKey in oPages) {
+      if (sKey === "entitySet" && oPages.entitySet === sEntityKey) {
+        if (oPages.component && oPages.component.name === sPageComponent) {
+          if (oPages.pages) {
+            var aSiblingkeys = Object.keys(oPages.pages);
+            findDuplicate(aSiblingkeys);
+          }
+          oLogger$2.info(oPages);
+          return oPages;
+        }
+      } else if (typeof oPages[sKey] === "object" && !Array.isArray(oPages[sKey])) {
+        if (oPageStructure) {
+          break;
+        }
+        if (sKey === "pages" || sParentKey === "pages") {
+          oPageStructure = iterateFind(oPages[sKey], sEntityKey, sPageComponent, sChildPageId, sKey);
+        }
+      } else if (sKey === "pages" && Array.isArray(oPages[sKey])) {
+        throw new Error("Manifest should have sap.ui.generic.app.pages as Object structure and not array ");
+      }
+    }
+    function findDuplicate(aSiblingkeys) {
+      if (aSiblingkeys.length) {
+        aSiblingkeys.filter(function (sPageKey) {
+          if (sPageKey === sChildPageId) {
+            throw new Error("Adding duplicate pageKey " + sChildPageId + " is not supported.");
+          }
+        });
+      }
+    }
+    return oPageStructure;
+  },
+  consistencyCheck: function (oChangeContent, sMergerType, aSupportedProperties) {
+    if (!oChangeContent["parentPage"]) {
+      throw new Error("Mandatory 'parentPage' parameter is not provided.");
+    }
+    if (!oChangeContent.parentPage.entitySet) {
+      throw new Error("Mandatory 'parentPage.entitySet' parameter is not provided.");
+    }
+    if (!oChangeContent.parentPage.component) {
+      throw new Error("Mandatory 'parentPage.component' parameter is not provided.");
+    }
+    if (sMergerType === "ADD") {
+      if (!oChangeContent.childPage.id) {
+        throw new Error(" Add mandatory parameter 'childPage.id' ");
+      }
+      if (!oChangeContent.childPage.definition) {
+        throw new Error("Mandatory 'childPageDefinition' are not provided. Add 'childPage.definition' to add the new page. ");
+      }
+      var aChildkeys = Object.keys(oChangeContent.childPage.definition);
+      aChildkeys.forEach(function (sKey) {
+        if (!fnIncludes(aSupportedProperties, sKey)) {
+          throw new Error("Changing " + sKey + " is not supported. The supported 'propertyPath' is: " + aSupportedProperties.join(","));
+        }
+      });
+      var aMandatoryParams = aSupportedProperties.filter(function (sComponentKey) {
+        return !fnIncludes(aChildkeys, sComponentKey);
+      });
+      if (aMandatoryParams.length) {
+        throw new Error("Mandatory parameter " + aMandatoryParams + " is not defined.");
+      }
+    } else if (sMergerType === "MODIFY") {
+      if (!oChangeContent.entityPropertyChange) {
+        throw new Error("Changes for \"" + oChangeContent["pageId"] + "\" are not provided.");
+      } else {
+        var oEntityPropertyChange = oChangeContent.entityPropertyChange;
+        if (!oEntityPropertyChange.propertyPath) {
+          throw new Error("Invalid change format: The mandatory 'propertyPath' is not defined. Please define the mandatory property 'propertyPath'");
+        }
+        if (!oEntityPropertyChange.operation || oEntityPropertyChange.operation !== "UPSERT") {
+          throw new Error("Invalid change format: The mandatory 'operation' is not defined or is not valid type. Please define the mandatory property 'operation' with type 'UPSERT");
+        }
+        if (!oEntityPropertyChange.propertyValue) {
+          throw new Error("Invalid change format: The mandatory 'propertyValue' is not defined. Please define the mandatory property 'propertyValue'");
+        }
+      }
+    }
+  }
+};
+
+var oLogger$1 = new FeLogger("manifestMerger.AddNewObjectPage").getLogger();
+var addNewObjectPage = {
+  applyChange: function (oManifest, oChange) {
+    oLogger$1.info("addNewPage use case");
+    var aSupportedProperties = ["navigationProperty", "entitySet"];
+    var oChangeContent = oChange.getContent();
+    var sChildPageId = oChangeContent.childPage && oChangeContent.childPage.id;
+    if (sChildPageId) {
+      DescriptorChangeCheck.checkIdNamespaceCompliance(sChildPageId, oChange);
+    }
+    mergerUtil.consistencyCheck(oChangeContent, "ADD", aSupportedProperties);
+    var sParentEntitySet = oChangeContent.parentPage.entitySet;
+    var sParentComponent = oChangeContent.parentPage.component;
+    var oPageStructure = mergerUtil.iterateAndFind(oManifest["sap.ui.generic.app"], sParentEntitySet, sParentComponent, sChildPageId);
+    var oComponentContent = {
+      "name": "sap.suite.ui.generic.template.ObjectPage"
+    };
+    if (oPageStructure) {
+      if (oPageStructure.pages && Array.isArray(oPageStructure.pages)) {
+        throw Error("Manifest should have sap.ui.generic.app.pages as Object structure and not array");
+      }
+      ObjectPath.create(["pages", sChildPageId], oPageStructure);
+      ObjectPath.set(["pages", sChildPageId], oChangeContent.childPage.definition, oPageStructure);
+      ObjectPath.set(["pages", sChildPageId, "component"], oComponentContent, oPageStructure);
+    } else {
+      throw Error("The target content definition is invalid");
+    }
+    return oManifest;
+  }
+};
+
+var oLogger = new FeLogger("manifestMerger.ChangePageConfiguration").getLogger();
+var changePageConfiguration = {
+  applyChange: function (oManifest, oChange) {
+    oLogger.info("modifyPageConfiguration use case");
+    var oChangeContent = oChange.getContent();
+    mergerUtil.consistencyCheck(oChangeContent, "MODIFY");
+    var sParentEntitySet = oChangeContent.parentPage.entitySet;
+    var sParentComponent = oChangeContent.parentPage.component;
+    var oPageStructure = mergerUtil.iterateAndFind(oManifest["sap.ui.generic.app"], sParentEntitySet, sParentComponent);
+    var oPropertyChange = oChangeContent.entityPropertyChange;
+    var aPropertyKeys = Object.keys(oPropertyChange.propertyValue);
+    aPropertyKeys.forEach(function (sCurrentKey) {
+      var aPropertyPath = oPropertyChange.propertyPath.split("/");
+      aPropertyPath.push(sCurrentKey);
+      var vVal = ObjectPath.get(aPropertyPath, oPageStructure);
+      if (vVal && typeof vVal === "object") {
+        var oPropertyPathContent = ObjectPath.create(aPropertyPath, oPageStructure);
+        Object.assign(oPropertyPathContent, oPropertyChange.propertyValue[sCurrentKey]);
+      } else {
+        ObjectPath.set(aPropertyPath, oPropertyChange.propertyValue[sCurrentKey], oPageStructure);
+      }
+    });
+    return oManifest;
+  }
+};
+
+var _exports = {};
+function applyChange(manifest, change) {
+  var _manifest$sapUi, _manifest$sapUi$routi;
+  var changeContent = change.getContent();
+  var pageID = changeContent === null || changeContent === void 0 ? void 0 : changeContent.page;
+  var targets = ((_manifest$sapUi = manifest["sap.ui5"]) === null || _manifest$sapUi === void 0 ? void 0 : (_manifest$sapUi$routi = _manifest$sapUi.routing) === null || _manifest$sapUi$routi === void 0 ? void 0 : _manifest$sapUi$routi.targets) || ({});
+  var pageSettings;
+  var propertyChange = changeContent === null || changeContent === void 0 ? void 0 : changeContent.entityPropertyChange;
+  if ((propertyChange === null || propertyChange === void 0 ? void 0 : propertyChange.operation) !== "UPSERT" || !(propertyChange !== null && propertyChange !== void 0 && propertyChange.propertyPath) || !(propertyChange !== null && propertyChange !== void 0 && propertyChange.propertyValue) || propertyChange !== null && propertyChange !== void 0 && propertyChange.propertyPath.startsWith("/")) {
+    return manifest;
+  }
+  for (var p in targets) {
+    if (targets[p].id === pageID) {
+      var _targets$p$name;
+      if ((_targets$p$name = targets[p].name) !== null && _targets$p$name !== void 0 && _targets$p$name.startsWith("sap.fe.templates.")) {
+        var _targets$p, _targets$p$options;
+        pageSettings = ((_targets$p = targets[p]) === null || _targets$p === void 0 ? void 0 : (_targets$p$options = _targets$p.options) === null || _targets$p$options === void 0 ? void 0 : _targets$p$options.settings) || ({});
+        break;
+      }
+    }
+  }
+  if (!pageSettings) {
+    return manifest;
+  }
+  var propertyPath = propertyChange.propertyPath.split("/");
+  if (propertyPath[0] === "controlConfiguration") {
+    var annotationPath = "";
+    for (var i = 1; i < propertyPath.length; i++) {
+      annotationPath += (i > 1 ? "/" : "") + propertyPath[i];
+      if (annotationPath.indexOf("@") > -1) {
+        propertyPath = ["controlConfiguration", annotationPath].concat(propertyPath.slice(i + 1));
+        break;
+      }
+    }
+  }
+  ObjectPath.set(propertyPath, propertyChange.propertyValue, pageSettings);
+  return manifest;
+}
+_exports.applyChange = applyChange;
+
 var Registration = {
-  appdescr_ui5_addLibraries: AddLibrary,
-  appdescr_app_setTitle: SetTitle,
-  appdescr_ovp_changeCard: ChangeCard,
-  appdescr_ovp_addNewCard: AddNewCard,
-  appdescr_ovp_removeCard: DeleteCard
+  appdescr_ui5_addLibraries: () => Promise.resolve(AddLibrary),
+  appdescr_app_setTitle: () => Promise.resolve(SetTitle),
+  appdescr_ovp_changeCard: () => Promise.resolve(ChangeCard),
+  appdescr_ovp_addNewCard: () => Promise.resolve(AddNewCard),
+  appdescr_ovp_removeCard: () => Promise.resolve(DeleteCard),
+  appdescr_ui_generic_app_addNewObjectPage: () => Promise.resolve(addNewObjectPage),
+  appdescr_ui_generic_app_changePageConfiguration: () => Promise.resolve(changePageConfiguration),
+  appdescr_fe_changePageConfiguration: () => Promise.resolve(_exports)
 };
 
 var RegistrationBuild = {
-  appdescr_app_changeDataSource: ChangeDataSouce,
-  appdescr_ui5_addNewModelEnhanceWith: AddNewModelEnhanceWith,
-  appdescr_ui5_addComponentUsages: AddComponentUsages,
-  appdescr_ui5_setMinUI5Version: SetMinUI5Version,
-  appdescr_fiori_setRegistrationIds: SetRegistrationIds,
-  appdescr_ui5_setFlexExtensionPointEnabled: SetFlexExtensionPointEnabled,
-  appdescr_ui5_addNewModel: AddNewModel,
-  appdescr_app_addAnnotationsToOData: AddAnnotationsToOData,
-  appdescr_app_changeInbound: ChangeInbound
+  appdescr_app_changeDataSource: () => Promise.resolve(ChangeDataSouce),
+  appdescr_ui5_addNewModelEnhanceWith: () => Promise.resolve(AddNewModelEnhanceWith),
+  appdescr_ui5_addComponentUsages: () => Promise.resolve(AddComponentUsages),
+  appdescr_ui5_setMinUI5Version: () => Promise.resolve(SetMinUI5Version),
+  appdescr_fiori_setRegistrationIds: () => Promise.resolve(SetRegistrationIds),
+  appdescr_ui5_setFlexExtensionPointEnabled: () => Promise.resolve(SetFlexExtensionPointEnabled),
+  appdescr_ui5_addNewModel: () => Promise.resolve(AddNewModel),
+  appdescr_app_addAnnotationsToOData: () => Promise.resolve(AddAnnotationsToOData),
+  appdescr_app_changeInbound: () => Promise.resolve(ChangeInbound),
+  appdescr_fiori_setAbstract: () => Promise.resolve(SetAbstract)
 };
 var RegistrationCopy = Object.assign({}, Registration);
 var RegistrationBuild$1 = Object.assign(RegistrationCopy, RegistrationBuild);