@sapui5/sap.fe.core 1.100.0 → 1.102.0

package/src/sap/fe/core/buildingBlocks/BuildingBlockRuntime.js

@@ -0,0 +1,935 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+
+function _settle(pact, state, value) {
+  if (!pact.s) {
+    if (value instanceof _Pact) {
+      if (value.s) {
+        if (state & 1) {
+          state = value.s;
+        }
+
+        value = value.v;
+      } else {
+        value.o = _settle.bind(null, pact, state);
+        return;
+      }
+    }
+
+    if (value && value.then) {
+      value.then(_settle.bind(null, pact, state), _settle.bind(null, pact, 2));
+      return;
+    }
+
+    pact.s = state;
+    pact.v = value;
+    var observer = pact.o;
+
+    if (observer) {
+      observer(pact);
+    }
+  }
+}
+
+var _Pact = /*#__PURE__*/function () {
+  function _Pact() {}
+
+  _Pact.prototype.then = function (onFulfilled, onRejected) {
+    var result = new _Pact();
+    var state = this.s;
+
+    if (state) {
+      var callback = state & 1 ? onFulfilled : onRejected;
+
+      if (callback) {
+        try {
+          _settle(result, 1, callback(this.v));
+        } catch (e) {
+          _settle(result, 2, e);
+        }
+
+        return result;
+      } else {
+        return this;
+      }
+    }
+
+    this.o = function (_this) {
+      try {
+        var value = _this.v;
+
+        if (_this.s & 1) {
+          _settle(result, 1, onFulfilled ? onFulfilled(value) : value);
+        } else if (onRejected) {
+          _settle(result, 1, onRejected(value));
+        } else {
+          _settle(result, 2, value);
+        }
+      } catch (e) {
+        _settle(result, 2, e);
+      }
+    };
+
+    return result;
+  };
+
+  return _Pact;
+}();
+
+function _isSettledPact(thenable) {
+  return thenable instanceof _Pact && thenable.s & 1;
+}
+
+function _forTo(array, body, check) {
+  var i = -1,
+      pact,
+      reject;
+
+  function _cycle(result) {
+    try {
+      while (++i < array.length && (!check || !check())) {
+        result = body(i);
+
+        if (result && result.then) {
+          if (_isSettledPact(result)) {
+            result = result.v;
+          } else {
+            result.then(_cycle, reject || (reject = _settle.bind(null, pact = new _Pact(), 2)));
+            return;
+          }
+        }
+      }
+
+      if (pact) {
+        _settle(pact, 1, result);
+      } else {
+        pact = result;
+      }
+    } catch (e) {
+      _settle(pact || (pact = new _Pact()), 2, e);
+    }
+  }
+
+  _cycle();
+
+  return pact;
+}
+
+sap.ui.define(["sap/base/Log", "sap/base/util/uid", "sap/fe/core/buildingBlocks/AttributeModel", "sap/fe/core/helpers/BindingExpression", "sap/fe/macros/ResourceModel", "sap/ui/base/BindingParser", "sap/ui/core/util/XMLPreprocessor", "./TraceInfo"], function (Log, uid, AttributeModel, BindingExpression, ResourceModel, BindingParser, XMLPreprocessor, TraceInfo) {
+  "use strict";
+
+  var _templateObject, _templateObject2, _templateObject3;
+
+  var _exports = {};
+  var compileBinding = BindingExpression.compileBinding;
+
+  function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function () {}; return { s: F, n: function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function (e) { throw e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function () { it = it.call(o); }, n: function () { var step = it.next(); normalCompletion = step.done; return step; }, e: function (e) { didErr = true; err = e; }, f: function () { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+  function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+  function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+  function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+  function _catch(body, recover) {
+    try {
+      var result = body();
+    } catch (e) {
+      return recover(e);
+    }
+
+    if (result && result.then) {
+      return result.then(void 0, recover);
+    }
+
+    return result;
+  }
+
+  function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+
+  var processBuildingBlock = function (buildingBLockDefinition, oNode, oVisitor) {
+    var isPublic = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+
+    try {
+      var sFragmentName = buildingBLockDefinition.fragment || "".concat(buildingBLockDefinition.namespace, ".").concat(buildingBLockDefinition.name);
+      var sName = "this";
+      var mContexts = {};
+      var oMetadataContexts = {};
+      var oSettings = oVisitor.getSettings(); // TODO 0001 Move this elsewhere this is weird :)
+
+      if (oSettings.models["sap.fe.i18n"]) {
+        oSettings.models["sap.fe.i18n"].getResourceBundle().then(function (oResourceBundle) {
+          ResourceModel.setApplicationI18nBundle(oResourceBundle);
+        }).catch(function (error) {
+          Log.error(error);
+        });
+      }
+
+      var oMetadata = prepareMetadata(buildingBLockDefinition.metadata, buildingBLockDefinition.isOpen); //Inject storage for macros
+
+      if (!oSettings[sFragmentName]) {
+        oSettings[sFragmentName] = {};
+      } // First of all we need to visit the attributes
+
+
+      return Promise.resolve(processProperties(oMetadata, oSettings, oNode, isPublic, oVisitor, mContexts, oMetadataContexts)).then(function (_ref) {
+        var mMissingContext = _ref.mMissingContext,
+            propertyValues = _ref.propertyValues;
+        var initialKeys = Object.keys(propertyValues);
+
+        var _temp5 = _catch(function () {
+          // Aggregation and complex type support
+          return Promise.resolve(processChildren(oNode, oVisitor, oMetadata, isPublic, propertyValues)).then(function (oAggregations) {
+            function _temp4() {
+              if (oPreviousMacroInfo) {
+                //restore macro info if available
+                oSettings["_macroInfo"] = oPreviousMacroInfo;
+              } else {
+                delete oSettings["_macroInfo"];
+              }
+            }
+
+            var oInstance;
+            var oControlConfig = {};
+
+            if (oSettings.models.viewData) {
+              // Only used in the Field macro and even then maybe not really useful
+              oControlConfig = oSettings.models.viewData.getProperty("/controlConfiguration");
+            }
+
+            var processedPropertyValues = propertyValues;
+
+            if (isV1MacroDef(buildingBLockDefinition) && buildingBLockDefinition.create) {
+              processedPropertyValues = buildingBLockDefinition.create.call(buildingBLockDefinition, propertyValues, oControlConfig, oSettings, oAggregations, isPublic);
+              Object.keys(oMetadata.metadataContexts).forEach(function (sMetadataName) {
+                if (oMetadata.metadataContexts[sMetadataName].computed) {
+                  mContexts[sMetadataName] = processedPropertyValues[sMetadataName];
+                }
+              });
+              Object.keys(mMissingContext).forEach(function (sContextName) {
+                if (processedPropertyValues.hasOwnProperty(sContextName)) {
+                  mContexts[sContextName] = processedPropertyValues[sContextName];
+                }
+              });
+            } else if (buildingBLockDefinition.apiVersion === 2) {
+              Object.keys(propertyValues).forEach(function (propName) {
+                var oData = propertyValues[propName];
+
+                if (oData && oData.isA && oData.isA("sap.ui.model.Context") && !oData.getModel().isA("sap.ui.model.odata.v4.ODataMetaModel")) {
+                  propertyValues[propName] = oData.getObject();
+                }
+              });
+              var BuildingBlockClass = buildingBLockDefinition;
+              oInstance = new BuildingBlockClass(propertyValues
+              /*, oControlConfig, oSettings, oAggregations, isPublic*/
+              );
+            }
+
+            var oAttributesModel = new AttributeModel(oNode, processedPropertyValues, buildingBLockDefinition);
+            mContexts[sName] = oAttributesModel.createBindingContext("/");
+            var oPreviousMacroInfo; // Keep track
+
+            if (TraceInfo.isTraceInfoActive()) {
+              var oTraceInfo = TraceInfo.traceMacroCalls(sFragmentName, oMetadata, mContexts, oNode, oVisitor);
+
+              if (oTraceInfo) {
+                oPreviousMacroInfo = oSettings["_macroInfo"];
+                oSettings["_macroInfo"] = oTraceInfo.macroInfo;
+              }
+            }
+
+            validateMacroSignature(sFragmentName, oMetadata, mContexts, oNode);
+            var oContextVisitor = oVisitor.with(mContexts, buildingBLockDefinition.isOpen !== undefined ? !buildingBLockDefinition.isOpen : true);
+            var oParent = oNode.parentNode;
+            var iChildIndex;
+            var oPromise;
+
+            var _temp3 = function () {
+              if (oParent) {
+                iChildIndex = Array.from(oParent.children).indexOf(oNode);
+
+                if (isV1MacroDef(buildingBLockDefinition) && buildingBLockDefinition.getTemplate || buildingBLockDefinition.apiVersion === 2) {
+                  var oTemplate;
+                  var addDefaultNamespace = false;
+
+                  if (buildingBLockDefinition.apiVersion === 2) {
+                    oTemplate = oInstance.getTemplate();
+                    addDefaultNamespace = true;
+                  } else if (buildingBLockDefinition.getTemplate) {
+                    oTemplate = buildingBLockDefinition.getTemplate(processedPropertyValues);
+                  }
+
+                  var hasError = "";
+
+                  if (oTemplate) {
+                    if (!oTemplate.firstElementChild) {
+                      oTemplate = parseXMLString(oTemplate, addDefaultNamespace); // For safety purpose we try to detect trailing text in between XML Tags
+
+                      var iter = document.createNodeIterator(oTemplate, NodeFilter.SHOW_TEXT);
+                      var textnode = iter.nextNode();
+
+                      while (textnode) {
+                        if (textnode.textContent && textnode.textContent.trim().length > 0) {
+                          hasError = textnode.textContent;
+                        }
+
+                        textnode = iter.nextNode();
+                      }
+                    }
+
+                    if (oTemplate.localName === "parsererror") {
+                      // If there is a parseerror while processing the XML it means the XML itself is malformed, as such we rerun the template process
+                      // Setting isTraceMode true will make it so that each xml` expression is checked for validity from XML perspective and if an error is found it's returned instead of the normal fragment
+                      Log.error("Error while processing building block ".concat(buildingBLockDefinition.name));
+
+                      try {
+                        var _oInstance;
+
+                        isTraceMode = true;
+                        oTemplate = (_oInstance = oInstance) !== null && _oInstance !== void 0 && _oInstance.getTemplate ? oInstance.getTemplate() : buildingBLockDefinition.getTemplate(processedPropertyValues);
+                        oTemplate = parseXMLString(oTemplate, true);
+                      } finally {
+                        isTraceMode = false;
+                      }
+                    } else if (hasError.length > 0) {
+                      // If there is trailing text we create a standard error and display it.
+                      Log.error("Error while processing building block ".concat(buildingBLockDefinition.name));
+                      var oErrorText = createErrorXML(["Error while processing building block ".concat(buildingBLockDefinition.name), "Trailing text was found in the XML: ".concat(hasError)], oTemplate.outerHTML);
+                      oTemplate = parseXMLString(oErrorText, true);
+                    }
+
+                    oNode.replaceWith(oTemplate);
+                    oNode = oParent.children[iChildIndex];
+                    oPromise = oContextVisitor.visitNode(oNode);
+                  } else {
+                    oNode.remove();
+                    oPromise = Promise.resolve();
+                  }
+                } else {
+                  oPromise = oContextVisitor.insertFragment(sFragmentName, oNode);
+                }
+
+                return Promise.resolve(oPromise).then(function () {
+                  var oMacroElement = oParent.children[iChildIndex];
+
+                  if (Object.keys(oAggregations).length > 0) {
+                    Object.keys(oAggregations).forEach(function (sAggregationName) {
+                      var oAggregationElement = oAggregations[sAggregationName];
+
+                      if (oMacroElement !== null && oMacroElement !== undefined) {
+                        var oNewChild = document.createElementNS(oMacroElement.namespaceURI, sAggregationName);
+                        var oElementChild = oAggregationElement.firstElementChild;
+
+                        while (oElementChild) {
+                          var oNextChild = oElementChild.nextElementSibling;
+                          oNewChild.appendChild(oElementChild);
+                          oElementChild = oNextChild;
+                        }
+
+                        if (sAggregationName !== "customData" && sAggregationName !== "dependents") {
+                          var sSlotName = oMetadata.aggregations[sAggregationName] && oMetadata.aggregations[sAggregationName].slot || sAggregationName;
+                          var oTargetElement = oMacroElement.querySelector("slot[name='" + sSlotName + "']");
+
+                          if (oTargetElement) {
+                            oTargetElement.replaceWith.apply(oTargetElement, _toConsumableArray(oNewChild.children));
+                          }
+                        } else {
+                          oMacroElement.appendChild(oNewChild);
+                        }
+                      }
+                    });
+                  }
+
+                  if (oMacroElement) {
+                    var oRemainingSlots = oMacroElement.querySelectorAll("slot");
+                    oRemainingSlots.forEach(function (oSlotElement) {
+                      oSlotElement.remove();
+                    });
+                  }
+                });
+              }
+            }();
+
+            return _temp3 && _temp3.then ? _temp3.then(_temp4) : _temp4(_temp3);
+          });
+        }, function (e) {
+          // In case there is a generic error (usually code error), we retrieve the current context information and create a dedicated error message
+          var traceDetails = {
+            initialProperties: {},
+            resolvedProperties: {},
+            missingContexts: mMissingContext
+          };
+
+          var _iterator = _createForOfIteratorHelper(initialKeys),
+              _step;
+
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var _propertyName = _step.value;
+              var _propertyValue = propertyValues[_propertyName];
+
+              if (_propertyValue && _propertyValue.isA && _propertyValue.isA("sap.ui.model.Context")) {
+                traceDetails.initialProperties[_propertyName] = {
+                  path: _propertyValue.getPath(),
+                  value: _propertyValue.getObject()
+                };
+              } else {
+                traceDetails.initialProperties[_propertyName] = _propertyValue;
+              }
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+
+          for (var propertyName in propertyValues) {
+            var propertyValue = propertyValues[propertyName];
+
+            if (!initialKeys.includes(propertyName)) {
+              if (propertyValue && propertyValue.isA && propertyValue.isA("sap.ui.model.Context")) {
+                traceDetails.resolvedProperties[propertyName] = {
+                  path: propertyValue.getPath(),
+                  value: propertyValue.getObject()
+                };
+              } else {
+                traceDetails.resolvedProperties[propertyName] = propertyValue;
+              }
+            }
+          }
+
+          var errorAny = e;
+          Log.error(errorAny, errorAny);
+          var oError = createErrorXML(["Error while processing building block ".concat(buildingBLockDefinition.name), errorAny.stack], oNode.outerHTML, traceDetails);
+          var oTemplate = parseXMLString(oError, true);
+          oNode.replaceWith(oTemplate);
+        });
+
+        if (_temp5 && _temp5.then) return _temp5.then(function () {});
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+
+  var processChildren = function (oNode, oVisitor, oMetadata, isPublic, propertyValues) {
+    try {
+      var oAggregations = {};
+
+      var _temp2 = function () {
+        if (oNode.firstElementChild !== null) {
+          // If there are aggregation we need to visit the childNodes first and foremost
+          return Promise.resolve(oVisitor.visitChildNodes(oNode)).then(function () {
+            var oFirstElementChild = oNode.firstElementChild;
+
+            while (oFirstElementChild !== null) {
+              var sChildName = oFirstElementChild.localName;
+
+              if (Object.keys(oMetadata.aggregations).indexOf(sChildName) !== -1 && (!isPublic || oMetadata.aggregations[sChildName].isPublic)) {
+                oAggregations[oFirstElementChild.localName] = oFirstElementChild;
+              } else if (Object.keys(oMetadata.properties).indexOf(sChildName) !== -1) {
+                // Object Type properties
+                propertyValues[sChildName] = {};
+
+                for (var _i = 0, _Object$keys = Object.keys(oFirstElementChild.attributes); _i < _Object$keys.length; _i++) {
+                  var attributeIndex = _Object$keys[_i];
+                  propertyValues[sChildName][oFirstElementChild.attributes[attributeIndex].localName] = oFirstElementChild.attributes[attributeIndex].value;
+                }
+              }
+
+              oFirstElementChild = oFirstElementChild.nextElementSibling;
+            }
+          });
+        }
+      }();
+
+      return Promise.resolve(_temp2 && _temp2.then ? _temp2.then(function () {
+        return oAggregations;
+      }) : oAggregations);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+
+  var processProperties = function (oMetadata, oSettings, oNode, isPublic, oVisitor, mContexts, oMetadataContexts) {
+    try {
+      function _temp10() {
+        // Sort keys to be sure contextPath is before metaPath ( yes I'm desperate )
+        aDefinitionContextsKeys = aDefinitionContextsKeys.sort(function (a, b) {
+          return a > b ? 1 : -1;
+        });
+
+        var _iterator2 = _createForOfIteratorHelper(aDefinitionContextsKeys),
+            _step2;
+
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var sAttributeName = _step2.value;
+            var bDoNotResolve = isPublic && !oDefinitionContexts[sAttributeName].isPublic && oNode.hasAttribute(sAttributeName);
+
+            var oMetadataContext = _getMetadataContext(oSettings, oNode, sAttributeName, oVisitor, bDoNotResolve, oMetadata.isOpen);
+
+            if (oMetadataContext) {
+              oMetadataContext.name = sAttributeName;
+              addSingleContext(mContexts, oVisitor, oMetadataContext, oMetadataContexts);
+
+              if (sAttributeName === "entitySet" && !oSettings.bindingContexts.hasOwnProperty(sAttributeName) || sAttributeName === "contextPath" && !oSettings.bindingContexts.hasOwnProperty(sAttributeName)) {
+                oSettings.bindingContexts[sAttributeName] = mContexts[sAttributeName];
+              }
+
+              if (sAttributeName === "contextPath") {
+                oSettings.currentContextPath = mContexts[sAttributeName];
+              }
+
+              propertyValues[sAttributeName] = mContexts[sAttributeName];
+            } else {
+              mMissingContext[sAttributeName] = true;
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+
+        return {
+          mMissingContext: mMissingContext,
+          propertyValues: propertyValues
+        };
+      }
+
+      var mMissingContext = {};
+      var oDefinitionProperties = oMetadata.properties;
+      var oDefinitionContexts = oMetadata.metadataContexts;
+      oSettings.currentContextPath = oSettings.bindingContexts.contextPath; // Retrieve properties values
+
+      var aDefinitionPropertiesKeys = Object.keys(oDefinitionProperties);
+      var aDefinitionContextsKeys = Object.keys(oDefinitionContexts);
+      var propertyValues = {};
+
+      var _temp11 = _forTo(aDefinitionPropertiesKeys, function (j) {
+        var sKeyValue = aDefinitionPropertiesKeys[j];
+
+        if (oDefinitionProperties[sKeyValue].type === "object") {
+          propertyValues[sKeyValue] = {}; // To avoid vales being reused accross macros
+        } else {
+          propertyValues[sKeyValue] = oDefinitionProperties[sKeyValue].defaultValue;
+        }
+
+        var _temp7 = function () {
+          if (oNode.hasAttribute(sKeyValue) && isPublic && !oDefinitionProperties[sKeyValue].isPublic) {
+            Log.error("Property ".concat(sKeyValue, " was ignored as it is not intended for public usage"));
+          } else {
+            var _temp12 = function () {
+              if (oNode.hasAttribute(sKeyValue)) {
+                return Promise.resolve(oVisitor.visitAttribute(oNode, oNode.attributes.getNamedItem(sKeyValue))).then(function () {
+                  var vValue = oNode.getAttribute(sKeyValue);
+
+                  if (vValue !== undefined) {
+                    propertyValues[sKeyValue] = vValue;
+                  }
+                });
+              }
+            }();
+
+            if (_temp12 && _temp12.then) return _temp12.then(function () {});
+          }
+        }();
+
+        if (_temp7 && _temp7.then) return _temp7.then(function () {});
+      });
+
+      return Promise.resolve(_temp11 && _temp11.then ? _temp11.then(_temp10) : _temp10(_temp11));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+
+  var LOGGER_SCOPE = "sap.fe.core.buildingBlocks.BuildingBlockRuntime";
+  var DOMParserInstance = new DOMParser();
+  var isTraceMode = false;
+
+  /**
+   * Typeguard for checking if a building block use API 1.
+   *
+   * @param buildingBlockDefinition
+   * @returns `true` if the building block is using API 1.
+   */
+  function isV1MacroDef(buildingBlockDefinition) {
+    return buildingBlockDefinition.apiVersion === undefined || buildingBlockDefinition.apiVersion === 1;
+  }
+
+  function validateMacroMetadataContext(sName, mContexts, oContextSettings, sKey) {
+    var oContext = mContexts[sKey];
+    var oContextObject = oContext === null || oContext === void 0 ? void 0 : oContext.getObject();
+
+    if (oContextSettings.required && (!oContext || oContextObject === null)) {
+      throw new Error("".concat(sName, ": Required metadataContext '").concat(sKey, "' is missing"));
+    } else if (oContextObject) {
+      // If context object has $kind property, $Type should not be checked
+      // Therefore remove from context settings
+      if (oContextObject.hasOwnProperty("$kind") && oContextSettings.$kind) {
+        // Check if the $kind is part of the allowed ones
+        if (oContextSettings.$kind.indexOf(oContextObject["$kind"]) === -1) {
+          throw new Error("".concat(sName, ": '").concat(sKey, "' must be '$kind' '").concat(oContextSettings["$kind"], "' but is '").concat(oContextObject.$kind, "': ").concat(oContext.getPath()));
+        }
+      } else if (oContextObject.hasOwnProperty("$Type") && oContextSettings.$Type) {
+        // Check only $Type
+        if (oContextSettings.$Type.indexOf(oContextObject["$Type"]) === -1) {
+          throw new Error("".concat(sName, ": '").concat(sKey, "' must be '$Type' '").concat(oContextSettings["$Type"], "' but is '").concat(oContextObject.$Type, "': ").concat(oContext.getPath()));
+        }
+      }
+    }
+  }
+
+  function validateMacroSignature(sName, oMetadata, mContexts, oNode) {
+    var aMetadataContextKeys = oMetadata.metadataContexts && Object.keys(oMetadata.metadataContexts) || [],
+        aProperties = oMetadata.properties && Object.keys(oMetadata.properties) || [],
+        oAttributeNames = {}; // collect all attributes to find unchecked properties
+
+    Object.keys(oNode.attributes).forEach(function (iKey) {
+      var sKey = oNode.attributes[iKey].name;
+      oAttributeNames[sKey] = true;
+    }); //Check metadataContexts
+
+    aMetadataContextKeys.forEach(function (sKey) {
+      var oContextSettings = oMetadata.metadataContexts[sKey];
+      validateMacroMetadataContext(sName, mContexts, oContextSettings, sKey);
+      delete oAttributeNames[sKey];
+    }); //Check properties
+
+    aProperties.forEach(function (sKey) {
+      var oPropertySettings = oMetadata.properties[sKey];
+
+      if (!oNode.hasAttribute(sKey)) {
+        if (oPropertySettings.required && !oPropertySettings.hasOwnProperty("defaultValue")) {
+          throw new Error(sName + ": " + "Required property '" + sKey + "' is missing");
+        }
+      } else {
+        delete oAttributeNames[sKey];
+      }
+    }); // Unchecked properties
+
+    Object.keys(oAttributeNames).forEach(function (sKey) {
+      // no check for properties which start with underscore "_" or contain a colon ":" (different namespace), e.g. xmlns:trace, trace:macroID, unittest:id
+      if (sKey.indexOf(":") < 0 && !sKey.startsWith("xmlns")) {
+        Log.warning("Unchecked parameter: ".concat(sName, ": ").concat(sKey), undefined, LOGGER_SCOPE);
+      }
+    });
+  }
+  /**
+   * Ensures that the metadata for the building block are properly defined.
+   *
+   * @param buildingBlockMetadata The metadata received from the input
+   * @param isOpen Whether the building block is open or not
+   * @returns A set of completed metadata for further processing
+   */
+
+
+  _exports.validateMacroSignature = validateMacroSignature;
+
+  function prepareMetadata(buildingBlockMetadata) {
+    var isOpen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+    if (buildingBlockMetadata) {
+      var oProperties = {};
+      var oAggregations = {
+        "dependents": {
+          type: "sap.ui.core.Element"
+        },
+        "customData": {
+          type: "sap.ui.core.Element"
+        }
+      };
+      var oMetadataContexts = {};
+      Object.keys(buildingBlockMetadata.properties).forEach(function (sPropertyName) {
+        if (buildingBlockMetadata.properties[sPropertyName].type !== "sap.ui.model.Context") {
+          oProperties[sPropertyName] = buildingBlockMetadata.properties[sPropertyName];
+        } else {
+          oMetadataContexts[sPropertyName] = buildingBlockMetadata.properties[sPropertyName];
+        }
+      }); // Merge events into properties as they are handled identically
+
+      if (buildingBlockMetadata.events) {
+        Object.keys(buildingBlockMetadata.events).forEach(function (sEventName) {
+          oProperties[sEventName] = buildingBlockMetadata.events[sEventName];
+        });
+      }
+
+      if (buildingBlockMetadata.aggregations) {
+        Object.keys(buildingBlockMetadata.aggregations).forEach(function (sPropertyName) {
+          oAggregations[sPropertyName] = buildingBlockMetadata.aggregations[sPropertyName];
+        });
+      }
+
+      return {
+        properties: oProperties,
+        aggregations: oAggregations,
+        metadataContexts: oMetadataContexts,
+        isOpen: isOpen
+      };
+    } else {
+      return {
+        metadataContexts: {},
+        aggregations: {
+          "dependents": {
+            type: "sap.ui.core.Element"
+          },
+          "customData": {
+            type: "sap.ui.core.Element"
+          }
+        },
+        properties: {},
+        isOpen: isOpen
+      };
+    }
+  }
+
+  function _getMetadataContext(oSettings, oNode, sAttributeName, oVisitor, bDoNotResolve, isOpen) {
+    var oMetadataContext;
+
+    if (!bDoNotResolve && oNode.hasAttribute(sAttributeName)) {
+      var sAttributeValue = oNode.getAttribute(sAttributeName);
+      var sMetaPath; // oVisitor.getResult(sAttributeValue, oNode);
+
+      oMetadataContext = BindingParser.complexParser(sAttributeValue);
+
+      if (!oMetadataContext) {
+        if (sAttributeValue.startsWith("uid--")) {
+          var oData = myStore[sAttributeValue];
+          var sContextPath = "/" + sAttributeValue;
+          oSettings.models.converterContext.setProperty(sContextPath, oData);
+          oMetadataContext = {
+            model: "converterContext",
+            path: sContextPath
+          };
+        } else if (sAttributeName === "metaPath" && oSettings.currentContextPath || sAttributeName === "contextPath") {
+          if (sAttributeValue && sAttributeValue.startsWith("/")) {
+            // absolute path - we just use this one
+            sMetaPath = sAttributeValue;
+          } else {
+            var _sContextPath = oSettings.currentContextPath.getPath();
+
+            if (!_sContextPath.endsWith("/")) {
+              _sContextPath += "/";
+            }
+
+            sMetaPath = _sContextPath + sAttributeValue;
+          }
+
+          oMetadataContext = {
+            model: "metaModel",
+            path: sMetaPath
+          };
+        } else {
+          oMetadataContext = {
+            model: "metaModel",
+            path: oSettings.bindingContexts.entitySet ? oSettings.bindingContexts.entitySet.getPath(sAttributeValue) : sAttributeValue
+          };
+        }
+      }
+    } else if (oSettings.bindingContexts.hasOwnProperty(sAttributeName)) {
+      oMetadataContext = {
+        model: sAttributeName,
+        path: ""
+      };
+    } else if (isOpen) {
+      try {
+        if (oVisitor.getContext("".concat(sAttributeName, ">"))) {
+          oMetadataContext = {
+            model: sAttributeName,
+            path: ""
+          };
+        }
+      } catch (e) {
+        oMetadataContext = undefined;
+      }
+    }
+
+    return oMetadataContext;
+  }
+
+  function addSingleContext(mContexts, oVisitor, oCtx, oMetadataContexts) {
+    var sKey = oCtx.name || oCtx.model || undefined;
+
+    if (oMetadataContexts[sKey]) {
+      return; // do not add twice
+    }
+
+    try {
+      var sContextPath = oCtx.path;
+
+      if (oCtx.model != null) {
+        sContextPath = oCtx.model + ">" + sContextPath;
+      }
+
+      var mSetting = oVisitor.getSettings();
+
+      if (!mSetting.bindingContexts[oCtx.model] && mSetting.models[oCtx.model]) {
+        mContexts[sKey] = mSetting.models[oCtx.model].getContext(oCtx.path); // add the context to the visitor
+      } else {
+        mContexts[sKey] = oVisitor.getContext(sContextPath); // add the context to the visitor
+      }
+
+      oMetadataContexts[sKey] = mContexts[sKey]; // make it available inside metadataContexts JSON object
+    } catch (ex) {//console.error(ex);
+      // ignore the context as this can only be the case if the model is not ready, i.e. not a preprocessing model but maybe a model for
+      // providing afterwards
+      // TODO 0002 not yet implemented
+      //mContexts["_$error"].oModel.setProperty("/" + sKey, ex);
+    }
+  }
+  /**
+   * Register a building block definition to be used inside the xml template processor.
+   *
+   * @param buildingBlockDefinition The building block definition
+   */
+
+
+  function registerBuildingBlock(buildingBlockDefinition) {
+    XMLPreprocessor.plugIn(function (oNode, oVisitor) {
+      return processBuildingBlock(buildingBlockDefinition, oNode, oVisitor);
+    }, buildingBlockDefinition.namespace, buildingBlockDefinition.xmlTag || buildingBlockDefinition.name);
+
+    if (buildingBlockDefinition.publicNamespace) {
+      XMLPreprocessor.plugIn(function (oNode, oVisitor) {
+        return processBuildingBlock(buildingBlockDefinition, oNode, oVisitor, true);
+      }, buildingBlockDefinition.publicNamespace, buildingBlockDefinition.xmlTag || buildingBlockDefinition.name);
+    }
+  }
+
+  _exports.registerBuildingBlock = registerBuildingBlock;
+
+  function createErrorXML(errorMessages, xmlFragment, additionalData) {
+    var errorLabels = errorMessages.map(function (errorMessage) {
+      return xml(_templateObject || (_templateObject = _taggedTemplateLiteral(["<m:Label text=\"", "\"/>"])), escapeXML(errorMessage));
+    });
+    var additionalText = "";
+
+    if (additionalData) {
+      additionalText = xml(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["<m:VBox>\n\t\t\t\t\t\t<m:Label text=\"Trace Info\"/>\n\t\t\t\t\t\t<code:CodeEditor type=\"json\" value=\"", "\" height=\"300px\" width=\"100vh\"/>\n\t\t\t\t\t</m:VBox>"])), escapeXML(JSON.stringify(additionalData, null, 4)));
+    }
+
+    return xml(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["<m:VBox xmlns:m=\"sap.m\" xmlns:code=\"sap.ui.codeeditor\">\n\t\t\t\t", "\n\t\t\t\t<m:HBox>\n\t\t\t\t\t<m:VBox>\n\t\t\t\t\t\t<m:Label text=\"How the building block was called\"/>\n\t\t\t\t\t\t<code:CodeEditor type=\"xml\" value=\"", "\" height=\"300px\" width=\"100vh\"/>\n\t\t\t\t\t</m:VBox>\n\t\t\t\t\t", "\n\t\t\t\t</m:HBox>\n\t\t\t</m:VBox>"])), errorLabels, escapeXML(xmlFragment), additionalText);
+  }
+
+  var myStore = {};
+
+  function storeValue(values) {
+    var propertyUID = "uid--".concat(uid());
+    myStore[propertyUID] = values;
+    return propertyUID;
+  }
+  /**
+   * Parse an XML string and return the associated document.
+   *
+   * @param xmlString The xml string
+   * @param addDefaultNamespaces Whether or not we should add default namespace
+   * @returns The XML document.
+   */
+
+
+  function parseXMLString(xmlString) {
+    var addDefaultNamespaces = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+    if (addDefaultNamespaces) {
+      xmlString = "<template\n\t\t\t\t\t\txmlns:template=\"http://schemas.sap.com/sapui5/extension/sap.ui.core.template/1\"\n\t\t\t\t\t\txmlns:m=\"sap.m\"\n\t\t\t\t\t\txmlns:core=\"sap.ui.core\"\n\t\t\t\t\t\txmlns:customData=\"http://schemas.sap.com/sapui5/extension/sap.ui.core.CustomData/1\">".concat(xmlString, "</template>");
+    }
+
+    var xmlDocument = DOMParserInstance.parseFromString(xmlString, "text/xml");
+    var output = xmlDocument.firstElementChild;
+
+    while (((_output = output) === null || _output === void 0 ? void 0 : _output.localName) === "template") {
+      var _output;
+
+      output = output.firstElementChild;
+    }
+
+    return output;
+  }
+  /**
+   * Escape an XML string to include it in an XML fragment.
+   *
+   * @param str The string to escape
+   * @returns The escaped string.
+   */
+
+
+  function escapeXML(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\n/g, "&#10;").replace(/\{/g, "\\{").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  }
+  /**
+   * Escape an XML attribute value.
+   *
+   * @param val The attribute value to escape.
+   * @returns The escaped string.
+   */
+
+
+  function escapeXMLAttributeValue(val) {
+    return val.replace(/&/g, "&amp;").replace(/</g, "&lt;");
+  }
+  /**
+   * Create a string representation of the template literal while handling special object case.
+   *
+   * @param strings The string parts of the template literal
+   * @param values The values part of the template literal
+   * @returns The XML string document representing the string that was used.
+   */
+
+
+  var xml = function (strings) {
+    var outStr = "";
+    var i;
+
+    for (var _len = arguments.length, values = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      values[_key - 1] = arguments[_key];
+    }
+
+    for (i = 0; i < values.length; i++) {
+      var _values$i, _values$i2;
+
+      outStr += strings[i]; // Handle the different case of object, if it's an array we join them, if it's a binding expression (determined by _type) then we compile it.
+
+      if (Array.isArray(values[i])) {
+        outStr += values[i].flat(5).join("").trim();
+      } else if ((_values$i = values[i]) !== null && _values$i !== void 0 && _values$i._type) {
+        var compiledExpression = compileBinding(values[i]);
+        outStr += compiledExpression !== undefined ? escapeXMLAttributeValue(compiledExpression) : undefined;
+      } else if ((_values$i2 = values[i]) !== null && _values$i2 !== void 0 && _values$i2.getTemplate) {
+        outStr += values[i].getTemplate();
+      } else if (typeof values[i] === "object") {
+        var propertyUId = storeValue(values[i]);
+        outStr += "".concat(propertyUId);
+      } else {
+        outStr += values[i];
+      }
+    }
+
+    outStr += strings[i];
+    outStr = outStr.trim();
+
+    if (isTraceMode) {
+      var xmlResult = parseXMLString(outStr, true);
+
+      if (xmlResult && (xmlResult === null || xmlResult === void 0 ? void 0 : xmlResult.localName) === "parsererror") {
+        var errorMessage = xmlResult.innerText || xmlResult.innerHTML;
+        return createErrorXML([errorMessage.split("\n")[0]], outStr);
+      }
+    }
+
+    return outStr;
+  };
+
+  _exports.xml = xml;
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["BuildingBlockRuntime.ts"],"names":["pact","state","value","s","v","o","bind","then","observer","prototype","onFulfilled","onRejected","result","callback","e","_this","thenable","array","body","check","i","reject","_cycle","length","recover","processBuildingBlock","buildingBLockDefinition","oNode","oVisitor","isPublic","sFragmentName","fragment","namespace","name","sName","mContexts","oMetadataContexts","oSettings","getSettings","models","getResourceBundle","oResourceBundle","ResourceModel","setApplicationI18nBundle","catch","error","Log","oMetadata","prepareMetadata","metadata","isOpen","processProperties","mMissingContext","propertyValues","initialKeys","Object","keys","processChildren","oAggregations","oPreviousMacroInfo","oInstance","oControlConfig","viewData","getProperty","processedPropertyValues","isV1MacroDef","create","call","metadataContexts","forEach","sMetadataName","computed","sContextName","hasOwnProperty","apiVersion","propName","oData","isA","getModel","getObject","BuildingBlockClass","oAttributesModel","AttributeModel","createBindingContext","TraceInfo","isTraceInfoActive","oTraceInfo","traceMacroCalls","macroInfo","validateMacroSignature","oContextVisitor","with","undefined","oParent","parentNode","iChildIndex","oPromise","Array","from","children","indexOf","getTemplate","oTemplate","addDefaultNamespace","hasError","firstElementChild","parseXMLString","iter","document","createNodeIterator","NodeFilter","SHOW_TEXT","textnode","nextNode","textContent","trim","localName","isTraceMode","oErrorText","createErrorXML","outerHTML","replaceWith","visitNode","remove","Promise","resolve","insertFragment","oMacroElement","sAggregationName","oAggregationElement","oNewChild","createElementNS","namespaceURI","oElementChild","oNextChild","nextElementSibling","appendChild","sSlotName","aggregations","slot","oTargetElement","querySelector","oRemainingSlots","querySelectorAll","oSlotElement","traceDetails","initialProperties","resolvedProperties","missingContexts","propertyName","propertyValue","path","getPath","includes","errorAny","oError","stack","visitChildNodes","oFirstElementChild","sChildName","properties","attributes","attributeIndex","aDefinitionContextsKeys","sort","a","b","sAttributeName","bDoNotResolve","oDefinitionContexts","hasAttribute","oMetadataContext","_getMetadataContext","addSingleContext","bindingContexts","currentContextPath","oDefinitionProperties","contextPath","aDefinitionPropertiesKeys","j","sKeyValue","type","defaultValue","visitAttribute","getNamedItem","vValue","getAttribute","LOGGER_SCOPE","DOMParserInstance","DOMParser","buildingBlockDefinition","validateMacroMetadataContext","oContextSettings","sKey","oContext","oContextObject","required","Error","$kind","$Type","aMetadataContextKeys","aProperties","oAttributeNames","iKey","oPropertySettings","startsWith","warning","buildingBlockMetadata","oProperties","sPropertyName","events","sEventName","sAttributeValue","sMetaPath","BindingParser","complexParser","myStore","sContextPath","converterContext","setProperty","model","endsWith","entitySet","getContext","oCtx","mSetting","ex","registerBuildingBlock","XMLPreprocessor","plugIn","xmlTag","publicNamespace","errorMessages","xmlFragment","additionalData","errorLabels","map","errorMessage","xml","escapeXML","additionalText","JSON","stringify","storeValue","values","propertyUID","uid","xmlString","addDefaultNamespaces","xmlDocument","parseFromString","output","str","replace","escapeXMLAttributeValue","val","strings","outStr","isArray","flat","join","_type","compiledExpression","compileBinding","propertyUId","xmlResult","innerText","innerHTML","split"],"mappings":"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","sourceRoot":".","sourcesContent":["import Log from \"sap/base/Log\";\nimport uid from \"sap/base/util/uid\";\nimport AttributeModel from \"sap/fe/core/buildingBlocks/AttributeModel\";\nimport {\n\tBuildingBlockAggregationDefinition,\n\tBuildingBlockBase,\n\tBuildingBlockDefinition,\n\tBuildingBlockDefinitionV1,\n\tBuildingBlockMetadata,\n\tBuildingBlockMetadataContextDefinition,\n\tBuildingBlockPropertyDefinition\n} from \"sap/fe/core/buildingBlocks/BuildingBlock\";\nimport { compileBinding } from \"sap/fe/core/helpers/BindingExpression\";\nimport ResourceModel from \"sap/fe/macros/ResourceModel\";\nimport BindingParser from \"sap/ui/base/BindingParser\";\nimport XMLPreprocessor from \"sap/ui/core/util/XMLPreprocessor\";\nimport Context from \"sap/ui/model/Context\";\nimport JSONModel from \"sap/ui/model/json/JSONModel\";\nimport TraceInfo from \"./TraceInfo\";\n\nconst LOGGER_SCOPE = \"sap.fe.core.buildingBlocks.BuildingBlockRuntime\";\nconst DOMParserInstance = new DOMParser();\nlet isTraceMode = false;\n\ntype ResolvedBuildingBlockMetadata = {\n\tproperties: Record<string, BuildingBlockPropertyDefinition>;\n\taggregations: Record<string, BuildingBlockAggregationDefinition>;\n\tmetadataContexts: Record<string, BuildingBlockMetadataContextDefinition>;\n\tisOpen: boolean;\n};\n\ntype ICallback = {\n\tgetSettings(): any;\n\t/**\n\t * Visits the given node and either processes a template instruction, calls\n\t * a visitor, or simply calls both {@link\n\t * sap.ui.core.util.XMLPreprocessor.ICallback.visitAttributes visitAttributes}\n\t * and {@link sap.ui.core.util.XMLPreprocessor.ICallback.visitChildNodes\n\t * visitChildNodes}.\n\t *\n\t * @param {Node} oNode\n\t *   The XML DOM node\n\t * @returns {sap.ui.base.SyncPromise}\n\t *   A thenable which resolves with <code>undefined</code> as soon as visiting\n\t *   is done, or is rejected with a corresponding error if visiting fails\n\t **/\n\tvisitNode(oNode: Node): Promise<void>;\n\n\t/**\n\t * Inserts the fragment with the given name in place of the given element. Loads the\n\t * fragment, takes care of caching (for the current pre-processor run) and visits the\n\t * fragment's content once it has been imported into the element's owner document and\n\t * put into place. Loading of fragments is asynchronous if the template view is\n\t * asynchronous.\n\t *\n\t * @param {string} sFragmentName\n\t *   the fragment's resolved name\n\t * @param {Element} oElement\n\t *   the XML DOM element, e.g. <sap.ui.core:Fragment> or <core:ExtensionPoint>\n\t * @param {sap.ui.core.util._with} oWithControl\n\t *   the parent's \"with\" control\n\t * @returns {sap.ui.base.SyncPromise}\n\t * A sync promise which resolves with <code>undefined</code> as soon as the fragment\n\t *   has been inserted, or is rejected with a corresponding error if loading or visiting\n\t *   fails.\n\t */\n\tinsertFragment(sFragment: string, oElement: Element, oWith?: any): Promise<void>;\n\tvisitAttribute(oNode: Element, oAttribute: Attr): Promise<void>;\n\tvisitChildNodes(oNode: Node): Promise<void>;\n\t/**\n\t * Interprets the given XML DOM attribute value as a binding and returns the\n\t * resulting value.\n\t * @param {string} sValue\n\t *   An XML DOM attribute value\n\t * @param {Element} [oElement]\n\t *   The XML DOM element the attribute value belongs to (needed only for\n\t *   warnings which are logged to the console)\n\t * @returns {sap.ui.base.SyncPromise|null}\n\t *   A thenable which resolves with the resulting value, or is rejected with a\n\t *   corresponding error (for example, an error thrown by a formatter) or\n\t *   <code>null</code> in case the binding is not ready (because it refers to a\n\t *   model which is not available) (since 1.57.0)\n\t */\n\tgetResult(sValue: string, element?: Element): Promise<any> | null;\n\tgetContext(sPath: string): Context;\n\t/**\n\t * Returns a callback interface instance for the given map of variables which\n\t * override currently known variables of the same name in <code>this</code>\n\t * parent interface or replace them altogether. Each variable name becomes a\n\t * named model with a corresponding object binding and can be used inside the\n\t * XML template in the usual way, that is, with a binding expression like\n\t * <code>\"{var>some/relative/path}\"</code> (see example).\n\t *\n\t * @param {object} [mVariables={}]\n\t *   Map from variable name (string) to value ({@link sap.ui.model.Context})\n\t * @param {boolean} [bReplace]\n\t *   Whether only the given variables are known in the new callback interface\n\t *   instance, no inherited ones\n\t * @returns {sap.ui.core.util.XMLPreprocessor.ICallback}\n\t *   A callback interface instance\n\t * @param mVariables\n\t * @param bReplace\n\t */\n\t\"with\"(mVariables?: any, bReplace?: boolean): ICallback;\n};\n\n/**\n * Typeguard for checking if a building block use API 1.\n *\n * @param buildingBlockDefinition\n * @returns `true` if the building block is using API 1.\n */\nfunction isV1MacroDef(buildingBlockDefinition: BuildingBlockDefinition): buildingBlockDefinition is BuildingBlockDefinitionV1 {\n\treturn buildingBlockDefinition.apiVersion === undefined || buildingBlockDefinition.apiVersion === 1;\n}\nfunction validateMacroMetadataContext(\n\tsName: string,\n\tmContexts: any,\n\toContextSettings: BuildingBlockMetadataContextDefinition,\n\tsKey: string\n) {\n\tconst oContext = mContexts[sKey];\n\tconst oContextObject = oContext?.getObject();\n\n\tif (oContextSettings.required && (!oContext || oContextObject === null)) {\n\t\tthrow new Error(`${sName}: Required metadataContext '${sKey}' is missing`);\n\t} else if (oContextObject) {\n\t\t// If context object has $kind property, $Type should not be checked\n\t\t// Therefore remove from context settings\n\t\tif (oContextObject.hasOwnProperty(\"$kind\") && oContextSettings.$kind) {\n\t\t\t// Check if the $kind is part of the allowed ones\n\t\t\tif (oContextSettings.$kind.indexOf(oContextObject[\"$kind\"]) === -1) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`${sName}: '${sKey}' must be '$kind' '${oContextSettings[\"$kind\"]}' but is '${\n\t\t\t\t\t\toContextObject.$kind\n\t\t\t\t\t}': ${oContext.getPath()}`\n\t\t\t\t);\n\t\t\t}\n\t\t} else if (oContextObject.hasOwnProperty(\"$Type\") && oContextSettings.$Type) {\n\t\t\t// Check only $Type\n\t\t\tif (oContextSettings.$Type.indexOf(oContextObject[\"$Type\"]) === -1) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`${sName}: '${sKey}' must be '$Type' '${oContextSettings[\"$Type\"]}' but is '${\n\t\t\t\t\t\toContextObject.$Type\n\t\t\t\t\t}': ${oContext.getPath()}`\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n}\nexport function validateMacroSignature(sName: any, oMetadata: any, mContexts: any, oNode: any) {\n\tconst aMetadataContextKeys = (oMetadata.metadataContexts && Object.keys(oMetadata.metadataContexts)) || [],\n\t\taProperties = (oMetadata.properties && Object.keys(oMetadata.properties)) || [],\n\t\toAttributeNames: any = {};\n\n\t// collect all attributes to find unchecked properties\n\tObject.keys(oNode.attributes).forEach(function (iKey: string) {\n\t\tconst sKey = oNode.attributes[iKey].name;\n\t\toAttributeNames[sKey] = true;\n\t});\n\n\t//Check metadataContexts\n\taMetadataContextKeys.forEach(function (sKey: any) {\n\t\tconst oContextSettings = oMetadata.metadataContexts[sKey];\n\n\t\tvalidateMacroMetadataContext(sName, mContexts, oContextSettings, sKey);\n\t\tdelete oAttributeNames[sKey];\n\t});\n\t//Check properties\n\taProperties.forEach(function (sKey: any) {\n\t\tconst oPropertySettings = oMetadata.properties[sKey];\n\t\tif (!oNode.hasAttribute(sKey)) {\n\t\t\tif (oPropertySettings.required && !oPropertySettings.hasOwnProperty(\"defaultValue\")) {\n\t\t\t\tthrow new Error(sName + \": \" + \"Required property '\" + sKey + \"' is missing\");\n\t\t\t}\n\t\t} else {\n\t\t\tdelete oAttributeNames[sKey];\n\t\t}\n\t});\n\n\t// Unchecked properties\n\tObject.keys(oAttributeNames).forEach(function (sKey: string) {\n\t\t// no check for properties which start with underscore \"_\" or contain a colon \":\" (different namespace), e.g. xmlns:trace, trace:macroID, unittest:id\n\t\tif (sKey.indexOf(\":\") < 0 && !sKey.startsWith(\"xmlns\")) {\n\t\t\tLog.warning(`Unchecked parameter: ${sName}: ${sKey}`, undefined, LOGGER_SCOPE);\n\t\t}\n\t});\n}\n\n/**\n * Ensures that the metadata for the building block are properly defined.\n *\n * @param buildingBlockMetadata The metadata received from the input\n * @param isOpen Whether the building block is open or not\n * @returns A set of completed metadata for further processing\n */\nfunction prepareMetadata(buildingBlockMetadata?: BuildingBlockMetadata, isOpen = false): ResolvedBuildingBlockMetadata {\n\tif (buildingBlockMetadata) {\n\t\tconst oProperties: any = {};\n\t\tconst oAggregations: any = {\n\t\t\t\"dependents\": {\n\t\t\t\ttype: \"sap.ui.core.Element\"\n\t\t\t},\n\t\t\t\"customData\": {\n\t\t\t\ttype: \"sap.ui.core.Element\"\n\t\t\t}\n\t\t};\n\t\tconst oMetadataContexts: Record<string, BuildingBlockPropertyDefinition> = {};\n\n\t\tObject.keys(buildingBlockMetadata.properties).forEach(function (sPropertyName: string) {\n\t\t\tif (buildingBlockMetadata.properties[sPropertyName].type !== \"sap.ui.model.Context\") {\n\t\t\t\toProperties[sPropertyName] = buildingBlockMetadata.properties[sPropertyName];\n\t\t\t} else {\n\t\t\t\toMetadataContexts[sPropertyName] = buildingBlockMetadata.properties[sPropertyName];\n\t\t\t}\n\t\t});\n\t\t// Merge events into properties as they are handled identically\n\t\tif (buildingBlockMetadata.events) {\n\t\t\tObject.keys(buildingBlockMetadata.events).forEach(function (sEventName: string) {\n\t\t\t\toProperties[sEventName] = buildingBlockMetadata.events[sEventName];\n\t\t\t});\n\t\t}\n\t\tif (buildingBlockMetadata.aggregations) {\n\t\t\tObject.keys(buildingBlockMetadata.aggregations).forEach(function (sPropertyName: string) {\n\t\t\t\toAggregations[sPropertyName] = buildingBlockMetadata.aggregations[sPropertyName];\n\t\t\t});\n\t\t}\n\t\treturn {\n\t\t\tproperties: oProperties,\n\t\t\taggregations: oAggregations,\n\t\t\tmetadataContexts: oMetadataContexts,\n\t\t\tisOpen: isOpen\n\t\t};\n\t} else {\n\t\treturn {\n\t\t\tmetadataContexts: {},\n\t\t\taggregations: {\n\t\t\t\t\"dependents\": {\n\t\t\t\t\ttype: \"sap.ui.core.Element\"\n\t\t\t\t},\n\t\t\t\t\"customData\": {\n\t\t\t\t\ttype: \"sap.ui.core.Element\"\n\t\t\t\t}\n\t\t\t},\n\t\t\tproperties: {},\n\t\t\tisOpen: isOpen\n\t\t};\n\t}\n}\n\nfunction _getMetadataContext(\n\toSettings: any,\n\toNode: Element,\n\tsAttributeName: string,\n\toVisitor: ICallback,\n\tbDoNotResolve: boolean,\n\tisOpen: boolean\n) {\n\tlet oMetadataContext;\n\tif (!bDoNotResolve && oNode.hasAttribute(sAttributeName)) {\n\t\tconst sAttributeValue = oNode.getAttribute(sAttributeName) as string;\n\t\tlet sMetaPath;\n\t\t// oVisitor.getResult(sAttributeValue, oNode);\n\t\toMetadataContext = BindingParser.complexParser(sAttributeValue);\n\t\tif (!oMetadataContext) {\n\t\t\tif (sAttributeValue.startsWith(\"uid--\")) {\n\t\t\t\tconst oData = myStore[sAttributeValue];\n\t\t\t\tconst sContextPath = \"/\" + sAttributeValue;\n\t\t\t\toSettings.models.converterContext.setProperty(sContextPath, oData);\n\t\t\t\toMetadataContext = {\n\t\t\t\t\tmodel: \"converterContext\",\n\t\t\t\t\tpath: sContextPath\n\t\t\t\t};\n\t\t\t} else if ((sAttributeName === \"metaPath\" && oSettings.currentContextPath) || sAttributeName === \"contextPath\") {\n\t\t\t\tif (sAttributeValue && sAttributeValue.startsWith(\"/\")) {\n\t\t\t\t\t// absolute path - we just use this one\n\t\t\t\t\tsMetaPath = sAttributeValue;\n\t\t\t\t} else {\n\t\t\t\t\tlet sContextPath = oSettings.currentContextPath.getPath();\n\t\t\t\t\tif (!sContextPath.endsWith(\"/\")) {\n\t\t\t\t\t\tsContextPath += \"/\";\n\t\t\t\t\t}\n\t\t\t\t\tsMetaPath = sContextPath + sAttributeValue;\n\t\t\t\t}\n\t\t\t\toMetadataContext = {\n\t\t\t\t\tmodel: \"metaModel\",\n\t\t\t\t\tpath: sMetaPath\n\t\t\t\t};\n\t\t\t} else {\n\t\t\t\toMetadataContext = {\n\t\t\t\t\tmodel: \"metaModel\",\n\t\t\t\t\tpath: oSettings.bindingContexts.entitySet\n\t\t\t\t\t\t? oSettings.bindingContexts.entitySet.getPath(sAttributeValue)\n\t\t\t\t\t\t: sAttributeValue\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\t} else if (oSettings.bindingContexts.hasOwnProperty(sAttributeName)) {\n\t\toMetadataContext = {\n\t\t\tmodel: sAttributeName,\n\t\t\tpath: \"\"\n\t\t};\n\t} else if (isOpen) {\n\t\ttry {\n\t\t\tif (oVisitor.getContext(`${sAttributeName}>`)) {\n\t\t\t\toMetadataContext = {\n\t\t\t\t\tmodel: sAttributeName,\n\t\t\t\t\tpath: \"\"\n\t\t\t\t};\n\t\t\t}\n\t\t} catch (e) {\n\t\t\toMetadataContext = undefined;\n\t\t}\n\t}\n\treturn oMetadataContext;\n}\n\nasync function processProperties(\n\toMetadata: ResolvedBuildingBlockMetadata,\n\toSettings: any,\n\toNode: Element,\n\tisPublic: boolean,\n\toVisitor: ICallback,\n\tmContexts: any,\n\toMetadataContexts: any\n) {\n\tconst mMissingContext: any = {};\n\tconst oDefinitionProperties = oMetadata.properties;\n\tconst oDefinitionContexts = oMetadata.metadataContexts;\n\toSettings.currentContextPath = oSettings.bindingContexts.contextPath;\n\n\t// Retrieve properties values\n\tconst aDefinitionPropertiesKeys = Object.keys(oDefinitionProperties);\n\tlet aDefinitionContextsKeys = Object.keys(oDefinitionContexts);\n\tconst propertyValues: Record<string, any> = {};\n\tfor (let j = 0; j < aDefinitionPropertiesKeys.length; j++) {\n\t\tconst sKeyValue = aDefinitionPropertiesKeys[j];\n\t\tif (oDefinitionProperties[sKeyValue].type === \"object\") {\n\t\t\tpropertyValues[sKeyValue] = {}; // To avoid vales being reused accross macros\n\t\t} else {\n\t\t\tpropertyValues[sKeyValue] = oDefinitionProperties[sKeyValue].defaultValue;\n\t\t}\n\t\tif (oNode.hasAttribute(sKeyValue) && isPublic && !oDefinitionProperties[sKeyValue].isPublic) {\n\t\t\tLog.error(`Property ${sKeyValue} was ignored as it is not intended for public usage`);\n\t\t} else if (oNode.hasAttribute(sKeyValue)) {\n\t\t\tawait oVisitor.visitAttribute(oNode, oNode.attributes.getNamedItem(sKeyValue) as Attr);\n\t\t\tconst vValue = oNode.getAttribute(sKeyValue);\n\t\t\tif (vValue !== undefined) {\n\t\t\t\tpropertyValues[sKeyValue] = vValue;\n\t\t\t}\n\t\t}\n\t}\n\t// Sort keys to be sure contextPath is before metaPath ( yes I'm desperate )\n\taDefinitionContextsKeys = aDefinitionContextsKeys.sort(function (a: string, b: string) {\n\t\treturn a > b ? 1 : -1;\n\t});\n\tfor (const sAttributeName of aDefinitionContextsKeys) {\n\t\tconst bDoNotResolve = isPublic && !oDefinitionContexts[sAttributeName].isPublic && oNode.hasAttribute(sAttributeName);\n\t\tconst oMetadataContext = _getMetadataContext(oSettings, oNode, sAttributeName, oVisitor, bDoNotResolve, oMetadata.isOpen);\n\t\tif (oMetadataContext) {\n\t\t\toMetadataContext.name = sAttributeName;\n\t\t\taddSingleContext(mContexts, oVisitor, oMetadataContext, oMetadataContexts);\n\t\t\tif (\n\t\t\t\t(sAttributeName === \"entitySet\" && !oSettings.bindingContexts.hasOwnProperty(sAttributeName)) ||\n\t\t\t\t(sAttributeName === \"contextPath\" && !oSettings.bindingContexts.hasOwnProperty(sAttributeName))\n\t\t\t) {\n\t\t\t\toSettings.bindingContexts[sAttributeName] = mContexts[sAttributeName];\n\t\t\t}\n\t\t\tif (sAttributeName === \"contextPath\") {\n\t\t\t\toSettings.currentContextPath = mContexts[sAttributeName];\n\t\t\t}\n\t\t\tpropertyValues[sAttributeName] = mContexts[sAttributeName];\n\t\t} else {\n\t\t\tmMissingContext[sAttributeName] = true;\n\t\t}\n\t}\n\treturn { mMissingContext, propertyValues: propertyValues };\n}\n\nasync function processChildren(\n\toNode: Element,\n\toVisitor: ICallback,\n\toMetadata: ResolvedBuildingBlockMetadata,\n\tisPublic: boolean,\n\tpropertyValues: Record<string, any>\n) {\n\tconst oAggregations: any = {};\n\tif (oNode.firstElementChild !== null) {\n\t\t// If there are aggregation we need to visit the childNodes first and foremost\n\t\tawait oVisitor.visitChildNodes(oNode);\n\t\tlet oFirstElementChild: Element | null = oNode.firstElementChild;\n\t\twhile (oFirstElementChild !== null) {\n\t\t\tconst sChildName = oFirstElementChild.localName;\n\t\t\tif (\n\t\t\t\tObject.keys(oMetadata.aggregations).indexOf(sChildName) !== -1 &&\n\t\t\t\t(!isPublic || oMetadata.aggregations[sChildName].isPublic)\n\t\t\t) {\n\t\t\t\toAggregations[oFirstElementChild.localName] = oFirstElementChild;\n\t\t\t} else if (Object.keys(oMetadata.properties).indexOf(sChildName) !== -1) {\n\t\t\t\t// Object Type properties\n\t\t\t\tpropertyValues[sChildName] = {};\n\t\t\t\tfor (const attributeIndex of Object.keys(oFirstElementChild.attributes)) {\n\t\t\t\t\tpropertyValues[sChildName][oFirstElementChild.attributes[attributeIndex as any].localName] =\n\t\t\t\t\t\toFirstElementChild.attributes[attributeIndex as any].value;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\toFirstElementChild = oFirstElementChild.nextElementSibling;\n\t\t}\n\t}\n\treturn oAggregations;\n}\n\nasync function processBuildingBlock(\n\tbuildingBLockDefinition: BuildingBlockDefinition,\n\toNode: Element,\n\toVisitor: ICallback,\n\tisPublic = false\n) {\n\tconst sFragmentName = buildingBLockDefinition.fragment || `${buildingBLockDefinition.namespace}.${buildingBLockDefinition.name}`;\n\n\tconst sName = \"this\";\n\n\tconst mContexts: any = {};\n\tconst oMetadataContexts: any = {};\n\tconst oSettings = oVisitor.getSettings();\n\t// TODO 0001 Move this elsewhere this is weird :)\n\tif (oSettings.models[\"sap.fe.i18n\"]) {\n\t\toSettings.models[\"sap.fe.i18n\"]\n\t\t\t.getResourceBundle()\n\t\t\t.then(function (oResourceBundle: any) {\n\t\t\t\tResourceModel.setApplicationI18nBundle(oResourceBundle);\n\t\t\t})\n\t\t\t.catch(function (error: any) {\n\t\t\t\tLog.error(error);\n\t\t\t});\n\t}\n\tconst oMetadata = prepareMetadata(buildingBLockDefinition.metadata, buildingBLockDefinition.isOpen);\n\n\t//Inject storage for macros\n\tif (!oSettings[sFragmentName]) {\n\t\toSettings[sFragmentName] = {};\n\t}\n\n\t// First of all we need to visit the attributes\n\tconst { mMissingContext, propertyValues } = await processProperties(\n\t\toMetadata,\n\t\toSettings,\n\t\toNode,\n\t\tisPublic,\n\t\toVisitor,\n\t\tmContexts,\n\t\toMetadataContexts\n\t);\n\tconst initialKeys = Object.keys(propertyValues);\n\ttry {\n\t\t// Aggregation and complex type support\n\t\tconst oAggregations = await processChildren(oNode, oVisitor, oMetadata, isPublic, propertyValues);\n\t\tlet oInstance: any;\n\t\tlet oControlConfig = {};\n\n\t\tif (oSettings.models.viewData) {\n\t\t\t// Only used in the Field macro and even then maybe not really useful\n\t\t\toControlConfig = oSettings.models.viewData.getProperty(\"/controlConfiguration\");\n\t\t}\n\t\tlet processedPropertyValues = propertyValues;\n\t\tif (isV1MacroDef(buildingBLockDefinition) && buildingBLockDefinition.create) {\n\t\t\tprocessedPropertyValues = buildingBLockDefinition.create.call(\n\t\t\t\tbuildingBLockDefinition,\n\t\t\t\tpropertyValues,\n\t\t\t\toControlConfig,\n\t\t\t\toSettings,\n\t\t\t\toAggregations,\n\t\t\t\tisPublic\n\t\t\t);\n\t\t\tObject.keys(oMetadata.metadataContexts).forEach(function (sMetadataName: string) {\n\t\t\t\tif (oMetadata.metadataContexts[sMetadataName].computed) {\n\t\t\t\t\tmContexts[sMetadataName] = processedPropertyValues[sMetadataName];\n\t\t\t\t}\n\t\t\t});\n\t\t\tObject.keys(mMissingContext).forEach(function (sContextName: string) {\n\t\t\t\tif (processedPropertyValues.hasOwnProperty(sContextName)) {\n\t\t\t\t\tmContexts[sContextName] = processedPropertyValues[sContextName];\n\t\t\t\t}\n\t\t\t});\n\t\t} else if (buildingBLockDefinition.apiVersion === 2) {\n\t\t\tObject.keys(propertyValues).forEach((propName) => {\n\t\t\t\tconst oData = propertyValues[propName];\n\t\t\t\tif (\n\t\t\t\t\toData &&\n\t\t\t\t\toData.isA &&\n\t\t\t\t\toData.isA(\"sap.ui.model.Context\") &&\n\t\t\t\t\t!oData.getModel().isA(\"sap.ui.model.odata.v4.ODataMetaModel\")\n\t\t\t\t) {\n\t\t\t\t\tpropertyValues[propName] = oData.getObject();\n\t\t\t\t}\n\t\t\t});\n\t\t\tconst BuildingBlockClass = buildingBLockDefinition as typeof BuildingBlockBase;\n\t\t\toInstance = new BuildingBlockClass(propertyValues /*, oControlConfig, oSettings, oAggregations, isPublic*/);\n\t\t}\n\t\tconst oAttributesModel: JSONModel = new AttributeModel(oNode, processedPropertyValues, buildingBLockDefinition);\n\t\tmContexts[sName] = oAttributesModel.createBindingContext(\"/\");\n\n\t\tlet oPreviousMacroInfo: any;\n\n\t\t// Keep track\n\t\tif (TraceInfo.isTraceInfoActive()) {\n\t\t\tconst oTraceInfo = TraceInfo.traceMacroCalls(sFragmentName, oMetadata, mContexts, oNode, oVisitor);\n\t\t\tif (oTraceInfo) {\n\t\t\t\toPreviousMacroInfo = oSettings[\"_macroInfo\"];\n\t\t\t\toSettings[\"_macroInfo\"] = oTraceInfo.macroInfo;\n\t\t\t}\n\t\t}\n\t\tvalidateMacroSignature(sFragmentName, oMetadata, mContexts, oNode);\n\n\t\tconst oContextVisitor = oVisitor.with(\n\t\t\tmContexts,\n\t\t\tbuildingBLockDefinition.isOpen !== undefined ? !buildingBLockDefinition.isOpen : true\n\t\t);\n\t\tconst oParent = oNode.parentNode;\n\n\t\tlet iChildIndex: number;\n\t\tlet oPromise;\n\t\tif (oParent) {\n\t\t\tiChildIndex = Array.from(oParent.children).indexOf(oNode);\n\n\t\t\tif (\n\t\t\t\t(isV1MacroDef(buildingBLockDefinition) && buildingBLockDefinition.getTemplate) ||\n\t\t\t\tbuildingBLockDefinition.apiVersion === 2\n\t\t\t) {\n\t\t\t\tlet oTemplate;\n\t\t\t\tlet addDefaultNamespace = false;\n\t\t\t\tif (buildingBLockDefinition.apiVersion === 2) {\n\t\t\t\t\toTemplate = oInstance.getTemplate();\n\t\t\t\t\taddDefaultNamespace = true;\n\t\t\t\t} else if (buildingBLockDefinition.getTemplate) {\n\t\t\t\t\toTemplate = buildingBLockDefinition.getTemplate(processedPropertyValues);\n\t\t\t\t}\n\n\t\t\t\tlet hasError = \"\";\n\t\t\t\tif (oTemplate) {\n\t\t\t\t\tif (!oTemplate.firstElementChild) {\n\t\t\t\t\t\toTemplate = parseXMLString(oTemplate, addDefaultNamespace);\n\t\t\t\t\t\t// For safety purpose we try to detect trailing text in between XML Tags\n\t\t\t\t\t\tconst iter = document.createNodeIterator(oTemplate, NodeFilter.SHOW_TEXT);\n\t\t\t\t\t\tlet textnode = iter.nextNode();\n\t\t\t\t\t\twhile (textnode) {\n\t\t\t\t\t\t\tif (textnode.textContent && textnode.textContent.trim().length > 0) {\n\t\t\t\t\t\t\t\thasError = textnode.textContent;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\ttextnode = iter.nextNode();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tif (oTemplate.localName === \"parsererror\") {\n\t\t\t\t\t\t// If there is a parseerror while processing the XML it means the XML itself is malformed, as such we rerun the template process\n\t\t\t\t\t\t// Setting isTraceMode true will make it so that each xml` expression is checked for validity from XML perspective and if an error is found it's returned instead of the normal fragment\n\t\t\t\t\t\tLog.error(`Error while processing building block ${buildingBLockDefinition.name}`);\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tisTraceMode = true;\n\t\t\t\t\t\t\toTemplate = oInstance?.getTemplate\n\t\t\t\t\t\t\t\t? oInstance.getTemplate()\n\t\t\t\t\t\t\t\t: (buildingBLockDefinition as any).getTemplate(processedPropertyValues);\n\t\t\t\t\t\t\toTemplate = parseXMLString(oTemplate, true);\n\t\t\t\t\t\t} finally {\n\t\t\t\t\t\t\tisTraceMode = false;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if (hasError.length > 0) {\n\t\t\t\t\t\t// If there is trailing text we create a standard error and display it.\n\t\t\t\t\t\tLog.error(`Error while processing building block ${buildingBLockDefinition.name}`);\n\t\t\t\t\t\tconst oErrorText = createErrorXML(\n\t\t\t\t\t\t\t[\n\t\t\t\t\t\t\t\t`Error while processing building block ${buildingBLockDefinition.name}`,\n\t\t\t\t\t\t\t\t`Trailing text was found in the XML: ${hasError}`\n\t\t\t\t\t\t\t],\n\t\t\t\t\t\t\toTemplate.outerHTML\n\t\t\t\t\t\t);\n\t\t\t\t\t\toTemplate = parseXMLString(oErrorText, true);\n\t\t\t\t\t}\n\t\t\t\t\toNode.replaceWith(oTemplate);\n\t\t\t\t\toNode = oParent.children[iChildIndex];\n\t\t\t\t\toPromise = oContextVisitor.visitNode(oNode);\n\t\t\t\t} else {\n\t\t\t\t\toNode.remove();\n\t\t\t\t\toPromise = Promise.resolve();\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toPromise = oContextVisitor.insertFragment(sFragmentName, oNode);\n\t\t\t}\n\n\t\t\tawait oPromise;\n\t\t\tconst oMacroElement = oParent.children[iChildIndex];\n\n\t\t\tif (Object.keys(oAggregations).length > 0) {\n\t\t\t\tObject.keys(oAggregations).forEach(function (sAggregationName: string) {\n\t\t\t\t\tconst oAggregationElement = oAggregations[sAggregationName];\n\t\t\t\t\tif (oMacroElement !== null && oMacroElement !== undefined) {\n\t\t\t\t\t\tconst oNewChild = document.createElementNS(oMacroElement.namespaceURI, sAggregationName);\n\t\t\t\t\t\tlet oElementChild = oAggregationElement.firstElementChild;\n\t\t\t\t\t\twhile (oElementChild) {\n\t\t\t\t\t\t\tconst oNextChild = oElementChild.nextElementSibling;\n\t\t\t\t\t\t\toNewChild.appendChild(oElementChild);\n\t\t\t\t\t\t\toElementChild = oNextChild;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (sAggregationName !== \"customData\" && sAggregationName !== \"dependents\") {\n\t\t\t\t\t\t\tconst sSlotName =\n\t\t\t\t\t\t\t\t(oMetadata.aggregations[sAggregationName] && oMetadata.aggregations[sAggregationName].slot) ||\n\t\t\t\t\t\t\t\tsAggregationName;\n\t\t\t\t\t\t\tconst oTargetElement = oMacroElement.querySelector(\"slot[name='\" + sSlotName + \"']\") as Element;\n\t\t\t\t\t\t\tif (oTargetElement) {\n\t\t\t\t\t\t\t\toTargetElement.replaceWith(...(oNewChild.children as any));\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\toMacroElement.appendChild(oNewChild);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t\tif (oMacroElement) {\n\t\t\t\tconst oRemainingSlots = oMacroElement.querySelectorAll(\"slot\");\n\t\t\t\toRemainingSlots.forEach(function (oSlotElement: any) {\n\t\t\t\t\toSlotElement.remove();\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\tif (oPreviousMacroInfo) {\n\t\t\t//restore macro info if available\n\t\t\toSettings[\"_macroInfo\"] = oPreviousMacroInfo;\n\t\t} else {\n\t\t\tdelete oSettings[\"_macroInfo\"];\n\t\t}\n\t} catch (e) {\n\t\t// In case there is a generic error (usually code error), we retrieve the current context information and create a dedicated error message\n\t\tconst traceDetails = {\n\t\t\tinitialProperties: {} as any,\n\t\t\tresolvedProperties: {} as any,\n\t\t\tmissingContexts: mMissingContext\n\t\t};\n\t\tfor (const propertyName of initialKeys) {\n\t\t\tconst propertyValue = propertyValues[propertyName];\n\t\t\tif (propertyValue && propertyValue.isA && propertyValue.isA(\"sap.ui.model.Context\")) {\n\t\t\t\ttraceDetails.initialProperties[propertyName] = {\n\t\t\t\t\tpath: propertyValue.getPath(),\n\t\t\t\t\tvalue: propertyValue.getObject()\n\t\t\t\t};\n\t\t\t} else {\n\t\t\t\ttraceDetails.initialProperties[propertyName] = propertyValue;\n\t\t\t}\n\t\t}\n\t\tfor (const propertyName in propertyValues) {\n\t\t\tconst propertyValue = propertyValues[propertyName];\n\t\t\tif (!initialKeys.includes(propertyName)) {\n\t\t\t\tif (propertyValue && propertyValue.isA && propertyValue.isA(\"sap.ui.model.Context\")) {\n\t\t\t\t\ttraceDetails.resolvedProperties[propertyName] = {\n\t\t\t\t\t\tpath: propertyValue.getPath(),\n\t\t\t\t\t\tvalue: propertyValue.getObject()\n\t\t\t\t\t};\n\t\t\t\t} else {\n\t\t\t\t\ttraceDetails.resolvedProperties[propertyName] = propertyValue;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tconst errorAny = e as any;\n\t\tLog.error(errorAny, errorAny);\n\t\tconst oError = createErrorXML(\n\t\t\t[`Error while processing building block ${buildingBLockDefinition.name}`, errorAny.stack],\n\t\t\toNode.outerHTML,\n\t\t\ttraceDetails\n\t\t);\n\t\tconst oTemplate = parseXMLString(oError, true);\n\t\toNode.replaceWith(oTemplate as any);\n\t}\n}\nfunction addSingleContext(mContexts: any, oVisitor: any, oCtx: any, oMetadataContexts: any) {\n\tconst sKey = oCtx.name || oCtx.model || undefined;\n\n\tif (oMetadataContexts[sKey]) {\n\t\treturn; // do not add twice\n\t}\n\ttry {\n\t\tlet sContextPath = oCtx.path;\n\t\tif (oCtx.model != null) {\n\t\t\tsContextPath = oCtx.model + \">\" + sContextPath;\n\t\t}\n\t\tconst mSetting = oVisitor.getSettings();\n\t\tif (!mSetting.bindingContexts[oCtx.model] && mSetting.models[oCtx.model]) {\n\t\t\tmContexts[sKey] = mSetting.models[oCtx.model].getContext(oCtx.path); // add the context to the visitor\n\t\t} else {\n\t\t\tmContexts[sKey] = oVisitor.getContext(sContextPath); // add the context to the visitor\n\t\t}\n\n\t\toMetadataContexts[sKey] = mContexts[sKey]; // make it available inside metadataContexts JSON object\n\t} catch (ex) {\n\t\t//console.error(ex);\n\t\t// ignore the context as this can only be the case if the model is not ready, i.e. not a preprocessing model but maybe a model for\n\t\t// providing afterwards\n\t\t// TODO 0002 not yet implemented\n\t\t//mContexts[\"_$error\"].oModel.setProperty(\"/\" + sKey, ex);\n\t}\n}\n\n/**\n * Register a building block definition to be used inside the xml template processor.\n *\n * @param buildingBlockDefinition The building block definition\n */\nexport function registerBuildingBlock(buildingBlockDefinition: BuildingBlockDefinition): void {\n\tXMLPreprocessor.plugIn(\n\t\t(oNode: Element, oVisitor: ICallback) => processBuildingBlock(buildingBlockDefinition, oNode, oVisitor),\n\t\tbuildingBlockDefinition.namespace,\n\t\tbuildingBlockDefinition.xmlTag || buildingBlockDefinition.name\n\t);\n\tif (buildingBlockDefinition.publicNamespace) {\n\t\tXMLPreprocessor.plugIn(\n\t\t\t(oNode: Element, oVisitor: ICallback) => processBuildingBlock(buildingBlockDefinition, oNode, oVisitor, true),\n\t\t\tbuildingBlockDefinition.publicNamespace,\n\t\t\tbuildingBlockDefinition.xmlTag || buildingBlockDefinition.name\n\t\t);\n\t}\n}\n\nfunction createErrorXML(errorMessages: string[], xmlFragment: string, additionalData?: object): string {\n\tconst errorLabels = errorMessages.map((errorMessage) => xml`<m:Label text=\"${escapeXML(errorMessage)}\"/>`);\n\tlet additionalText = \"\";\n\tif (additionalData) {\n\t\tadditionalText = xml`<m:VBox>\n\t\t\t\t\t\t<m:Label text=\"Trace Info\"/>\n\t\t\t\t\t\t<code:CodeEditor type=\"json\" value=\"${escapeXML(JSON.stringify(additionalData, null, 4))}\" height=\"300px\" width=\"100vh\"/>\n\t\t\t\t\t</m:VBox>`;\n\t}\n\treturn xml`<m:VBox xmlns:m=\"sap.m\" xmlns:code=\"sap.ui.codeeditor\">\n\t\t\t\t${errorLabels}\n\t\t\t\t<m:HBox>\n\t\t\t\t\t<m:VBox>\n\t\t\t\t\t\t<m:Label text=\"How the building block was called\"/>\n\t\t\t\t\t\t<code:CodeEditor type=\"xml\" value=\"${escapeXML(xmlFragment)}\" height=\"300px\" width=\"100vh\"/>\n\t\t\t\t\t</m:VBox>\n\t\t\t\t\t${additionalText}\n\t\t\t\t</m:HBox>\n\t\t\t</m:VBox>`;\n}\n\nconst myStore: Record<string, any> = {};\nfunction storeValue(values: any) {\n\tconst propertyUID = `uid--${uid()}`;\n\tmyStore[propertyUID] = values;\n\treturn propertyUID;\n}\n\n/**\n * Parse an XML string and return the associated document.\n *\n * @param xmlString The xml string\n * @param addDefaultNamespaces Whether or not we should add default namespace\n * @returns The XML document.\n */\nfunction parseXMLString(xmlString: string, addDefaultNamespaces = false): Element {\n\tif (addDefaultNamespaces) {\n\t\txmlString = `<template\n\t\t\t\t\t\txmlns:template=\"http://schemas.sap.com/sapui5/extension/sap.ui.core.template/1\"\n\t\t\t\t\t\txmlns:m=\"sap.m\"\n\t\t\t\t\t\txmlns:core=\"sap.ui.core\"\n\t\t\t\t\t\txmlns:customData=\"http://schemas.sap.com/sapui5/extension/sap.ui.core.CustomData/1\">${xmlString}</template>`;\n\t}\n\tconst xmlDocument = DOMParserInstance.parseFromString(xmlString, \"text/xml\");\n\tlet output = xmlDocument.firstElementChild;\n\twhile (output?.localName === \"template\") {\n\t\toutput = output.firstElementChild;\n\t}\n\treturn output as Element;\n}\n\n/**\n * Escape an XML string to include it in an XML fragment.\n *\n * @param str The string to escape\n * @returns The escaped string.\n */\nfunction escapeXML(str: string): string {\n\treturn str\n\t\t.replace(/&/g, \"&amp;\")\n\t\t.replace(/</g, \"&lt;\")\n\t\t.replace(/\\n/g, \"&#10;\")\n\t\t.replace(/\\{/g, \"\\\\{\")\n\t\t.replace(/>/g, \"&gt;\")\n\t\t.replace(/\"/g, \"&quot;\")\n\t\t.replace(/'/g, \"&apos;\");\n}\n\n/**\n * Escape an XML attribute value.\n *\n * @param val The attribute value to escape.\n * @returns The escaped string.\n */\nfunction escapeXMLAttributeValue(val: string): string {\n\treturn val.replace(/&/g, \"&amp;\").replace(/</g, \"&lt;\");\n}\n\n/**\n * Create a string representation of the template literal while handling special object case.\n *\n * @param strings The string parts of the template literal\n * @param values The values part of the template literal\n * @returns The XML string document representing the string that was used.\n */\nexport const xml = (strings: TemplateStringsArray, ...values: any[]) => {\n\tlet outStr = \"\";\n\tlet i;\n\tfor (i = 0; i < values.length; i++) {\n\t\toutStr += strings[i];\n\t\t// Handle the different case of object, if it's an array we join them, if it's a binding expression (determined by _type) then we compile it.\n\t\tif (Array.isArray(values[i])) {\n\t\t\toutStr += values[i].flat(5).join(\"\").trim();\n\t\t} else if (values[i]?._type) {\n\t\t\tconst compiledExpression = compileBinding(values[i]);\n\t\t\toutStr += compiledExpression !== undefined ? escapeXMLAttributeValue(compiledExpression) : undefined;\n\t\t} else if (values[i]?.getTemplate) {\n\t\t\toutStr += values[i].getTemplate();\n\t\t} else if (typeof values[i] === \"object\") {\n\t\t\tconst propertyUId = storeValue(values[i]);\n\t\t\toutStr += `${propertyUId}`;\n\t\t} else {\n\t\t\toutStr += values[i];\n\t\t}\n\t}\n\toutStr += strings[i];\n\toutStr = outStr.trim();\n\tif (isTraceMode) {\n\t\tconst xmlResult = parseXMLString(outStr, true);\n\t\tif (xmlResult && xmlResult?.localName === \"parsererror\") {\n\t\t\tconst errorMessage = (xmlResult as any).innerText || (xmlResult as any).innerHTML;\n\t\t\treturn createErrorXML([errorMessage.split(\"\\n\")[0]], outStr);\n\t\t}\n\t}\n\treturn outStr;\n};\n"]}