@sapui5/sap.fe.core 1.111.1 → 1.112.0

package/src/sap/fe/core/buildingBlocks/BuildingBlockTemplateProcessor-dbg.js

@@ -0,0 +1,905 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2023 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/Log", "sap/base/util/deepClone", "sap/base/util/uid", "sap/fe/core/buildingBlocks/AttributeModel", "sap/fe/core/converters/helpers/ConfigurableObject", "sap/fe/core/helpers/BindingToolkit", "sap/fe/core/helpers/TypeGuards", "sap/ui/base/BindingParser", "sap/ui/core/util/XMLPreprocessor", "sap/ui/model/json/JSONModel", "./TraceInfo"], function (Log, deepClone, uid, AttributeModel, ConfigurableObject, BindingToolkit, TypeGuards, BindingParser, XMLPreprocessor, JSONModel, TraceInfo) {
+  "use strict";
+
+  var _exports = {};
+  var isFunctionArray = TypeGuards.isFunctionArray;
+  var isContext = TypeGuards.isContext;
+  var isBindingToolkitExpression = BindingToolkit.isBindingToolkitExpression;
+  var compileExpression = BindingToolkit.compileExpression;
+  var Placement = ConfigurableObject.Placement;
+  const LOGGER_SCOPE = "sap.fe.core.buildingBlocks.BuildingBlockTemplateProcessor";
+  const XMLTEMPLATING_NS = "http://schemas.sap.com/sapui5/extension/sap.ui.core.template/1";
+  const DOMParserInstance = new DOMParser();
+  function validateMacroMetadataContext(sName, mContexts, oContextSettings, sKey) {
+    const oContext = mContexts[sKey];
+    const oContextObject = oContext === null || oContext === void 0 ? void 0 : oContext.getObject();
+    if (oContextSettings.required === true && (!oContext || oContextObject === null)) {
+      throw new Error(`${sName}: Required metadataContext '${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") && oContextObject.$kind !== undefined && oContextSettings.$kind !== undefined) {
+        // Check if the $kind is part of the allowed ones
+        if (oContextSettings.$kind.indexOf(oContextObject.$kind) === -1) {
+          throw new Error(`${sName}: '${sKey}' must be '$kind' '${oContextSettings["$kind"]}' but is '${oContextObject.$kind}': ${oContext.getPath()}`);
+        }
+      } else if (oContextObject.hasOwnProperty("$Type") && oContextObject.$Type !== undefined && oContextSettings.$Type) {
+        // Check only $Type
+        if (oContextSettings.$Type.indexOf(oContextObject.$Type) === -1) {
+          throw new Error(`${sName}: '${sKey}' must be '$Type' '${oContextSettings["$Type"]}' but is '${oContextObject.$Type}': ${oContext.getPath()}`);
+        }
+      }
+    }
+  }
+  function validateMacroSignature(sName, oMetadata, mContexts, oNode) {
+    const aMetadataContextKeys = oMetadata.metadataContexts && Object.keys(oMetadata.metadataContexts) || [],
+      aProperties = oMetadata.properties && Object.keys(oMetadata.properties) || [],
+      oAttributeNames = {};
+
+    // collect all attributes to find unchecked properties
+    const attributeNames = oNode.getAttributeNames();
+    for (const attributeName of attributeNames) {
+      oAttributeNames[attributeName] = true;
+    }
+
+    //Check metadataContexts
+    aMetadataContextKeys.forEach(function (sKey) {
+      const oContextSettings = oMetadata.metadataContexts[sKey];
+      validateMacroMetadataContext(sName, mContexts, oContextSettings, sKey);
+      delete oAttributeNames[sKey];
+    });
+    //Check properties
+    aProperties.forEach(function (sKey) {
+      const 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 contain a colon ":" (different namespace), e.g. xmlns:trace, trace:macroID, unittest:id
+      if (sKey.indexOf(":") < 0 && !sKey.startsWith("xmlns")) {
+        Log.warning(`Unchecked parameter: ${sName}: ${sKey}`, undefined, LOGGER_SCOPE);
+      }
+    });
+  }
+  _exports.validateMacroSignature = validateMacroSignature;
+  const SAP_UI_CORE_ELEMENT = "sap.ui.core.Element";
+  const SAP_UI_MODEL_CONTEXT = "sap.ui.model.Context";
+
+  /**
+   * Transforms the metadata of a building block by adding additional aggregations,
+   * and splitting properties into actual properties and metadata contexts.
+   *
+   * @param buildingBlockMetadata The metadata received from the input
+   * @returns The transformed metadata
+   */
+  _exports.SAP_UI_MODEL_CONTEXT = SAP_UI_MODEL_CONTEXT;
+  function transformMetadata(buildingBlockMetadata) {
+    const properties = {};
+    const aggregations = {
+      dependents: {
+        type: SAP_UI_CORE_ELEMENT,
+        slot: "dependents"
+      },
+      customData: {
+        type: SAP_UI_CORE_ELEMENT,
+        slot: "customData"
+      },
+      ...buildingBlockMetadata.aggregations
+    };
+    const metadataContexts = {};
+    for (const propertyName of Object.keys(buildingBlockMetadata.properties)) {
+      const propertyType = buildingBlockMetadata.properties[propertyName].type;
+      if (propertyType !== SAP_UI_MODEL_CONTEXT) {
+        properties[propertyName] = buildingBlockMetadata.properties[propertyName];
+      }
+      if ([SAP_UI_MODEL_CONTEXT, "object", "array"].includes(propertyType)) {
+        // Explicitly defined contexts, objects, and arrays may come from the metadataContext
+        metadataContexts[propertyName] = buildingBlockMetadata.properties[propertyName];
+      }
+    }
+    return {
+      ...buildingBlockMetadata,
+      properties,
+      metadataContexts,
+      aggregations
+    };
+  }
+
+  /**
+   * Checks the absolute or context paths and returns an appropriate MetaContext.
+   *
+   * @param oSettings Additional settings
+   * @param sAttributeValue The attribute value
+   * @returns The meta data context object
+   */
+  function _checkAbsoluteAndContextPaths(oSettings, sAttributeValue) {
+    let sMetaPath;
+    if (sAttributeValue && sAttributeValue.startsWith("/")) {
+      // absolute path - we just use this one
+      sMetaPath = sAttributeValue;
+    } else {
+      let sContextPath = oSettings.currentContextPath.getPath();
+      if (!sContextPath.endsWith("/")) {
+        sContextPath += "/";
+      }
+      sMetaPath = sContextPath + sAttributeValue;
+    }
+    return {
+      model: "metaModel",
+      path: sMetaPath
+    };
+  }
+
+  /**
+   * This method helps to create the metadata context in case it is not yet available in the store.
+   *
+   * @param oSettings Additional settings
+   * @param sAttributeName The attribute name
+   * @param sAttributeValue The attribute value
+   * @returns The meta data context object
+   */
+  function _createInitialMetadataContext(oSettings, sAttributeName, sAttributeValue) {
+    let returnContext;
+    if (sAttributeValue.startsWith("/uid--") && !oSettings.models.converterContext.getProperty(sAttributeValue)) {
+      const data = unstoreObjectValue(sAttributeValue);
+      oSettings.models.converterContext.setProperty(sAttributeValue, data);
+      returnContext = {
+        model: "converterContext",
+        path: sAttributeValue
+      };
+    } else if (sAttributeName === "metaPath" && oSettings.currentContextPath || sAttributeName === "contextPath") {
+      returnContext = _checkAbsoluteAndContextPaths(oSettings, sAttributeValue);
+    } else if (sAttributeValue && sAttributeValue.startsWith("/")) {
+      // absolute path - we just use this one
+      returnContext = {
+        model: "metaModel",
+        path: sAttributeValue
+      };
+    } else {
+      returnContext = {
+        model: "metaModel",
+        path: oSettings.bindingContexts.entitySet ? oSettings.bindingContexts.entitySet.getPath(sAttributeValue) : sAttributeValue
+      };
+    }
+    return returnContext;
+  }
+  function _getMetadataContext(oSettings, oNode, sAttributeName, oVisitor, bDoNotResolve, isOpen) {
+    let oMetadataContext;
+    if (!bDoNotResolve && oNode.hasAttribute(sAttributeName)) {
+      const sAttributeValue = oNode.getAttribute(sAttributeName);
+      oMetadataContext = BindingParser.complexParser(sAttributeValue);
+      if (!oMetadataContext) {
+        oMetadataContext = _createInitialMetadataContext(oSettings, sAttributeName, sAttributeValue);
+      }
+    } else if (oSettings.bindingContexts.hasOwnProperty(sAttributeName)) {
+      oMetadataContext = {
+        model: sAttributeName,
+        path: ""
+      };
+    } else if (isOpen) {
+      try {
+        if (oVisitor.getContext(`${sAttributeName}>`)) {
+          oMetadataContext = {
+            model: sAttributeName,
+            path: ""
+          };
+        }
+      } catch (e) {
+        return undefined;
+      }
+    }
+    return oMetadataContext;
+  }
+
+  /**
+   * Parse the incoming XML node and try to resolve the properties defined there.
+   *
+   * @param oMetadata The metadata for the building block
+   * @param oNode The XML node to parse
+   * @param isPublic Whether the building block is used in a public context or not
+   * @param oVisitor The visitor instance
+   */
+  async function processProperties(oMetadata, oNode, isPublic, oVisitor) {
+    const oDefinitionProperties = oMetadata.properties;
+
+    // Retrieve properties values
+    const aDefinitionPropertiesKeys = Object.keys(oDefinitionProperties);
+    const propertyValues = {};
+    for (const sKeyValue of aDefinitionPropertiesKeys) {
+      if (oDefinitionProperties[sKeyValue].type === "object") {
+        propertyValues[sKeyValue] = oDefinitionProperties[sKeyValue].defaultValue && deepClone(oDefinitionProperties[sKeyValue].defaultValue); // To avoid values being reused across macros
+      } else {
+        propertyValues[sKeyValue] = oDefinitionProperties[sKeyValue].defaultValue;
+      }
+      if (oNode.hasAttribute(sKeyValue) && isPublic && oDefinitionProperties[sKeyValue].isPublic === false) {
+        Log.error(`Property ${sKeyValue} was ignored as it is not intended for public usage`);
+      } else if (oNode.hasAttribute(sKeyValue)) {
+        await oVisitor.visitAttribute(oNode, oNode.attributes.getNamedItem(sKeyValue));
+        let value = oNode.getAttribute(sKeyValue);
+        if (value !== undefined && value !== null) {
+          if (typeof value === "string" && !value.startsWith("{")) {
+            switch (oDefinitionProperties[sKeyValue].type) {
+              case "boolean":
+                value = value === "true";
+                break;
+              case "number":
+                value = Number(value);
+                break;
+            }
+          }
+          value = value === null ? undefined : value;
+          propertyValues[sKeyValue] = value;
+        }
+      }
+    }
+    return propertyValues;
+  }
+
+  /**
+   * Parse the incoming XML node and try to resolve the binding contexts defined inside.
+   *
+   * @param oMetadata The metadata for the building block
+   * @param oSettings The settings object
+   * @param oNode The XML node to parse
+   * @param isPublic Whether the building block is used in a public context or not
+   * @param oVisitor The visitor instance
+   * @param mContexts The contexts to be used
+   * @param propertyValues The current property values
+   * @returns The processed and missing contexts
+   */
+  function processContexts(oMetadata, oSettings, oNode, isPublic, oVisitor, mContexts, propertyValues) {
+    oSettings.currentContextPath = oSettings.bindingContexts.contextPath;
+    const mMissingContext = {};
+    const oDefinitionContexts = oMetadata.metadataContexts;
+    const aDefinitionContextsKeys = Object.keys(oDefinitionContexts);
+    // Since the metaPath and other property can be relative to the contextPath we need to evaluate the current contextPath first
+    const contextPathIndex = aDefinitionContextsKeys.indexOf("contextPath");
+    if (contextPathIndex !== -1) {
+      // If it is defined we extract it and reinsert it in the first position of the array
+      const contextPathDefinition = aDefinitionContextsKeys.splice(contextPathIndex, 1);
+      aDefinitionContextsKeys.splice(0, 0, contextPathDefinition[0]);
+    }
+    for (const sAttributeName of aDefinitionContextsKeys) {
+      // If the context was resolved as a property (binding / xml aggregation) then we don't need to resolve it here.
+      const propertyValue = propertyValues[sAttributeName];
+      if (propertyValue !== undefined && typeof propertyValue === "object" && Object.keys(propertyValue).length > 0) {
+        delete oMetadata.metadataContexts[sAttributeName];
+        continue;
+      }
+      const bDoNotResolve = isPublic && oDefinitionContexts[sAttributeName].isPublic === false && oNode.hasAttribute(sAttributeName);
+      const oMetadataContext = _getMetadataContext(oSettings, oNode, sAttributeName, oVisitor, bDoNotResolve, oMetadata.isOpen ?? false);
+      if (oMetadataContext) {
+        oMetadataContext.name = sAttributeName;
+        addSingleContext(mContexts, oVisitor, oMetadataContext);
+        if ((sAttributeName === "entitySet" || sAttributeName === "contextPath") && !oSettings.bindingContexts.hasOwnProperty(sAttributeName)) {
+          oSettings.bindingContexts[sAttributeName] = mContexts[sAttributeName];
+        }
+        if (sAttributeName === "contextPath") {
+          oSettings.currentContextPath = mContexts[sAttributeName];
+        }
+        if (mContexts[sAttributeName] !== undefined) {
+          propertyValues[sAttributeName] = mContexts[sAttributeName];
+        } else if (typeof propertyValues[sAttributeName] === "string") {
+          // If the binding couldn't be resolved consider that there was no value here
+          delete oMetadata.metadataContexts[sAttributeName];
+        }
+      } else {
+        mMissingContext[sAttributeName] = true;
+      }
+    }
+    return mMissingContext;
+  }
+  function parseAggregation(oAggregation, processAggregations) {
+    const oOutObjects = {};
+    if (oAggregation && oAggregation.children.length > 0) {
+      const children = oAggregation.children;
+      for (let childIdx = 0; childIdx < children.length; childIdx++) {
+        const childDefinition = children[childIdx];
+        let childKey = childDefinition.getAttribute("key") || childDefinition.getAttribute("id");
+        if (childKey) {
+          childKey = `InlineXML_${childKey}`;
+          childDefinition.setAttribute("key", childKey);
+          let aggregationObject = {
+            key: childKey,
+            position: {
+              placement: childDefinition.getAttribute("placement") || Placement.After,
+              anchor: childDefinition.getAttribute("anchor") || undefined
+            },
+            type: "Slot"
+          };
+          if (processAggregations) {
+            aggregationObject = processAggregations(childDefinition, aggregationObject);
+          }
+          oOutObjects[aggregationObject.key] = aggregationObject;
+        } else if (childDefinition.tagName !== "slot") {
+          Log.error(`The aggregation ${childDefinition.nodeName} is missing a Key attribute. It is not displayed`);
+        }
+      }
+    }
+    return oOutObjects;
+  }
+
+  /**
+   * Processes the child nodes of the building block and parses them as either aggregations or object-/array-based values.
+   *
+   * @param oNode The XML node for which to process the children
+   * @param oVisitor The visitor instance
+   * @param oMetadata The metadata for the building block
+   * @param isPublic Whether the building block is used in a public context or not
+   * @param propertyValues The values of already parsed property
+   */
+  async function processChildren(oNode, oVisitor, oMetadata, isPublic, propertyValues) {
+    const oAggregations = {};
+    if (oNode.firstElementChild !== null) {
+      let oFirstElementChild = oNode.firstElementChild;
+      while (oFirstElementChild !== null) {
+        if (oFirstElementChild.namespaceURI === XMLTEMPLATING_NS) {
+          // In case we encounter a templating tag, run the visitor on it and continue with the resulting child
+          const oParent = oFirstElementChild.parentNode;
+          if (oParent) {
+            const iChildIndex = Array.from(oParent.children).indexOf(oFirstElementChild);
+            await oVisitor.visitNode(oFirstElementChild);
+            oFirstElementChild = oParent.children[iChildIndex] ? oParent.children[iChildIndex] : null;
+          } else {
+            // Not sure how this could happen but I also don't want to create infinite loops
+            oFirstElementChild = oFirstElementChild.nextElementSibling;
+          }
+        } else {
+          const sChildName = oFirstElementChild.localName;
+          let sAggregationName = sChildName;
+          if (sAggregationName[0].toUpperCase() === sAggregationName[0]) {
+            // not a sub aggregation, go back to default Aggregation
+            sAggregationName = oMetadata.defaultAggregation || "";
+          }
+          const aggregationDefinition = oMetadata.aggregations[sAggregationName];
+          if (aggregationDefinition !== undefined && !aggregationDefinition.slot) {
+            const parsedAggregation = parseAggregation(oFirstElementChild, aggregationDefinition.processAggregations);
+            propertyValues[sAggregationName] = parsedAggregation;
+            for (const parsedAggregationKey in parsedAggregation) {
+              oMetadata.aggregations[parsedAggregationKey] = parsedAggregation[parsedAggregationKey];
+            }
+          }
+          oFirstElementChild = oFirstElementChild.nextElementSibling;
+        }
+      }
+      oFirstElementChild = oNode.firstElementChild;
+      while (oFirstElementChild !== null) {
+        const oNextChild = oFirstElementChild.nextElementSibling;
+        const sChildName = oFirstElementChild.localName;
+        let sAggregationName = sChildName;
+        if (sAggregationName[0].toUpperCase() === sAggregationName[0]) {
+          // not a sub aggregation, go back to default Aggregation
+          sAggregationName = oMetadata.defaultAggregation || "";
+        }
+        if (Object.keys(oMetadata.aggregations).indexOf(sAggregationName) !== -1 && (!isPublic || oMetadata.aggregations[sAggregationName].isPublic === true)) {
+          const aggregationDefinition = oMetadata.aggregations[sAggregationName];
+          if (!aggregationDefinition.slot && oFirstElementChild !== null && oFirstElementChild.children.length > 0) {
+            await oVisitor.visitNode(oFirstElementChild);
+            let childDefinition = oFirstElementChild.firstElementChild;
+            while (childDefinition) {
+              const nextChild = childDefinition.nextElementSibling;
+              if (!aggregationDefinition.hasVirtualNode) {
+                const childWrapper = document.createElementNS(oNode.namespaceURI, childDefinition.getAttribute("key"));
+                childWrapper.appendChild(childDefinition);
+                oAggregations[childDefinition.getAttribute("key")] = childWrapper;
+              } else {
+                oAggregations[childDefinition.getAttribute("key")] = childDefinition;
+              }
+              childDefinition.removeAttribute("key");
+              childDefinition = nextChild;
+            }
+          } else if (aggregationDefinition.slot) {
+            await oVisitor.visitNode(oFirstElementChild);
+            if (sAggregationName !== sChildName) {
+              if (!oAggregations[sAggregationName]) {
+                const oNewChild = document.createElementNS(oNode.namespaceURI, sAggregationName);
+                oAggregations[sAggregationName] = oNewChild;
+              }
+              oAggregations[sAggregationName].appendChild(oFirstElementChild);
+            } else {
+              oAggregations[sAggregationName] = oFirstElementChild;
+            }
+          }
+        } else if (Object.keys(oMetadata.properties).indexOf(sAggregationName) !== -1) {
+          await oVisitor.visitNode(oFirstElementChild);
+          if (oMetadata.properties[sAggregationName].type === "object") {
+            // Object Type properties
+            const aggregationPropertyValues = {};
+            const attributeNames = oFirstElementChild.getAttributeNames();
+            for (const attributeName of attributeNames) {
+              aggregationPropertyValues[attributeName] = oFirstElementChild.getAttribute(attributeName);
+            }
+            if (oFirstElementChild.children.length) {
+              //retrieve one level subObject properties
+              for (let childIndex = 0; childIndex < oFirstElementChild.children.length; childIndex++) {
+                const subChild = oFirstElementChild.children[childIndex];
+                const subObjectKey = subChild.localName;
+                const subObject = {};
+                const subChildAttributeNames = subChild.getAttributeNames();
+                for (const subChildAttributeName of subChildAttributeNames) {
+                  subObject[subChildAttributeName] = subChild.getAttribute(subChildAttributeName);
+                }
+                aggregationPropertyValues[subObjectKey] = subObject;
+              }
+            }
+            propertyValues[sAggregationName] = aggregationPropertyValues;
+          } else if (oMetadata.properties[sAggregationName].type === "array") {
+            if (oFirstElementChild !== null && oFirstElementChild.children.length > 0) {
+              const children = oFirstElementChild.children;
+              const oOutObjects = [];
+              for (let childIdx = 0; childIdx < children.length; childIdx++) {
+                const childDefinition = children[childIdx];
+                // non keyed child, just add it to the aggregation
+                const myChild = {};
+                const attributeNames = childDefinition.getAttributeNames();
+                for (const attributeName of attributeNames) {
+                  myChild[attributeName] = childDefinition.getAttribute(attributeName);
+                }
+                oOutObjects.push(myChild);
+              }
+              propertyValues[sAggregationName] = oOutObjects;
+            }
+          }
+        }
+        oFirstElementChild = oNextChild;
+      }
+    }
+    return oAggregations;
+  }
+  function processSlots(oAggregations, oMetadataAggregations, oNode) {
+    let processCustomData = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    if (Object.keys(oAggregations).length > 0) {
+      Object.keys(oAggregations).forEach(function (sAggregationName) {
+        const oAggregationElement = oAggregations[sAggregationName];
+        if (oNode !== null && oNode !== undefined && oAggregationElement) {
+          // slots can have :: as keys which is not a valid aggregation name therefore replacing them
+          const oElementChild = oAggregationElement.firstElementChild;
+          if (sAggregationName !== "customData" && sAggregationName !== "dependents") {
+            const sSlotName = oMetadataAggregations[sAggregationName] !== undefined && oMetadataAggregations[sAggregationName].slot || sAggregationName;
+            const oTargetElement = oNode.querySelector(`slot[name='${sSlotName}']`);
+            if (oTargetElement !== null) {
+              const oNewChild = prepareAggregationElement(oNode, sAggregationName, oElementChild);
+              oTargetElement.replaceWith(...oNewChild.children); // Somehow TS doesn't like this but the documentation says is should work
+            }
+          } else if (processCustomData && oElementChild !== null) {
+            const oNewChild = prepareAggregationElement(oNode, sAggregationName, oElementChild);
+            oNode.appendChild(oNewChild);
+          }
+        }
+      });
+    }
+  }
+  function prepareAggregationElement(oNode, sAggregationName, oElementChild) {
+    const oNewChild = document.createElementNS(oNode.namespaceURI, sAggregationName.replace(/:/gi, "_"));
+    while (oElementChild) {
+      const oNextChild = oElementChild.nextElementSibling;
+      oNewChild.appendChild(oElementChild);
+      oElementChild = oNextChild;
+    }
+    return oNewChild;
+  }
+  async function processBuildingBlock(BuildingBlockClass, oNode, oVisitor) {
+    let isPublic = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    const oMetadata = transformMetadata(BuildingBlockClass.metadata);
+    const sFragmentName = oMetadata.fragment || `${oMetadata.namespace}.${oMetadata.xmlTag || oMetadata.name}`;
+    const mContexts = {};
+    const oSettings = oVisitor.getSettings();
+
+    // Add an empty converter context if there is none in order to have a place to store object values
+    oSettings.models.converterContext ??= new JSONModel();
+
+    //Inject storage for macros
+    if (!oSettings[sFragmentName]) {
+      oSettings[sFragmentName] = {};
+    }
+
+    // First of all we need to visit the attributes to resolve the properties and the metadata contexts
+    const propertyValues = await processProperties(oMetadata, oNode, isPublic, oVisitor);
+    const initialKeys = Object.keys(propertyValues);
+    const mMissingContext = processContexts(oMetadata, oSettings, oNode, isPublic, oVisitor, mContexts, propertyValues);
+    try {
+      // Aggregation and complex type support
+      const oAggregations = await processChildren(oNode, oVisitor, oMetadata, isPublic, propertyValues);
+      let oControlConfig = {};
+      if (oSettings.models.viewData) {
+        // Only used in the Field macro and even then maybe not really useful
+        oControlConfig = oSettings.models.viewData.getProperty("/controlConfiguration");
+      }
+      let processedPropertyValues = propertyValues;
+      Object.keys(propertyValues).forEach(propName => {
+        var _BuildingBlockClass$m, _oData, _oData$isA;
+        let oData = propertyValues[propName];
+        //check for additional processing function to validate / overwrite parameters
+        const originalDefinition = BuildingBlockClass === null || BuildingBlockClass === void 0 ? void 0 : (_BuildingBlockClass$m = BuildingBlockClass.metadata) === null || _BuildingBlockClass$m === void 0 ? void 0 : _BuildingBlockClass$m.properties[propName];
+        if (originalDefinition !== null && originalDefinition !== void 0 && originalDefinition.validate) {
+          oData = originalDefinition.validate(oData) || oData;
+        }
+        if ((_oData = oData) !== null && _oData !== void 0 && (_oData$isA = _oData.isA) !== null && _oData$isA !== void 0 && _oData$isA.call(_oData, SAP_UI_MODEL_CONTEXT) && !oData.getModel().isA("sap.ui.model.odata.v4.ODataMetaModel")) {
+          propertyValues[propName] = oData.getObject();
+        }
+      });
+      propertyValues.isPublic = isPublic;
+      const oInstance = new BuildingBlockClass({
+        ...propertyValues,
+        ...oAggregations
+      }, oControlConfig, oSettings);
+      processedPropertyValues = oInstance.getProperties();
+      Object.keys(oMetadata.metadataContexts).forEach(function (sContextName) {
+        if (processedPropertyValues.hasOwnProperty(sContextName)) {
+          const targetObject = processedPropertyValues[sContextName];
+          if (typeof targetObject === "object" && !isContext(targetObject)) {
+            const attributeValue = storeObjectValue(targetObject);
+            oSettings.models.converterContext.setProperty(attributeValue, targetObject);
+            const newContext = oSettings.models.converterContext.createBindingContext(attributeValue);
+            unstoreObjectValue(attributeValue);
+            mContexts[sContextName] = newContext;
+          } else if (!mContexts.hasOwnProperty(sContextName) && targetObject !== undefined) {
+            mContexts[sContextName] = targetObject;
+          }
+        }
+      });
+      const oAttributesModel = new AttributeModel(oNode, processedPropertyValues, BuildingBlockClass);
+      mContexts["this"] = oAttributesModel.createBindingContext("/");
+      let oPreviousMacroInfo;
+
+      // Keep track
+      if (TraceInfo.isTraceInfoActive()) {
+        const oTraceInfo = TraceInfo.traceMacroCalls(sFragmentName, oMetadata, mContexts, oNode, oVisitor);
+        if (oTraceInfo !== null && oTraceInfo !== void 0 && oTraceInfo.macroInfo) {
+          oPreviousMacroInfo = oSettings["_macroInfo"];
+          oSettings["_macroInfo"] = oTraceInfo.macroInfo;
+        }
+      }
+      validateMacroSignature(sFragmentName, oMetadata, mContexts, oNode);
+      const oContextVisitor = oVisitor.with(mContexts, oMetadata.isOpen !== undefined ? !oMetadata.isOpen : true);
+      const oParent = oNode.parentNode;
+      let iChildIndex;
+      let oPromise;
+      if (oParent) {
+        iChildIndex = Array.from(oParent.children).indexOf(oNode);
+        if (oMetadata.fragment) {
+          oPromise = oContextVisitor.insertFragment(sFragmentName, oNode);
+        } else {
+          const templateString = await oInstance.getTemplate(oNode);
+          if (BuildingBlockClass.isRuntime) {
+            // For runtime building blocks, we need to attach all objects to the converterContext directly, as the actual rendering takes place at runtime
+            for (const storeKey in temporaryObjectStore) {
+              const data = unstoreObjectValue(storeKey);
+              oSettings.models.converterContext.setProperty(storeKey, data);
+            }
+          }
+          let hasError = "";
+          if (templateString) {
+            let hasParseError = false;
+            let parsedTemplate = parseXMLString(templateString, true);
+            // For safety purpose we try to detect trailing text in between XML Tags
+            for (const element of parsedTemplate) {
+              const iter = document.createNodeIterator(element, NodeFilter.SHOW_TEXT);
+              let textnode = iter.nextNode();
+              if (element.localName === "parsererror") {
+                hasParseError = true;
+              }
+              while (textnode) {
+                if (textnode.textContent && textnode.textContent.trim().length > 0) {
+                  hasError = textnode.textContent;
+                }
+                textnode = iter.nextNode();
+              }
+            }
+            if (hasParseError) {
+              // 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
+              // If an error is found it's returned instead of the normal fragment
+              Log.error(`Error while processing building block ${oMetadata.xmlTag || oMetadata.name}`);
+              parsedTemplate = await processXmlInTrace(async () => {
+                var _oInstance$getTemplat;
+                const initialTemplate = await ((_oInstance$getTemplat = oInstance.getTemplate) === null || _oInstance$getTemplat === void 0 ? void 0 : _oInstance$getTemplat.call(oInstance, oNode));
+                return parseXMLString(initialTemplate ?? "", true);
+              });
+            } 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 ${oMetadata.xmlTag || oMetadata.name}`);
+              const oErrorText = createErrorXML([`Error while processing building block ${oMetadata.xmlTag || oMetadata.name}`, `Trailing text was found in the XML: ${hasError}`], parsedTemplate.map(template => template.outerHTML).join("\n"));
+              parsedTemplate = parseXMLString(oErrorText, true);
+            }
+            oNode.replaceWith(...parsedTemplate);
+            oNode = oParent.children[iChildIndex];
+            processSlots(oAggregations, oMetadata.aggregations, oNode, false);
+            oPromise = oContextVisitor.visitNode(oNode);
+          } else {
+            oNode.remove();
+            oPromise = Promise.resolve();
+          }
+        }
+        await oPromise;
+        const oMacroElement = oParent.children[iChildIndex];
+        processSlots(oAggregations, oMetadata.aggregations, oMacroElement, true);
+        if (oMacroElement !== undefined) {
+          const oRemainingSlots = oMacroElement.querySelectorAll("slot");
+          oRemainingSlots.forEach(function (oSlotElement) {
+            oSlotElement.remove();
+          });
+        }
+      }
+      if (oPreviousMacroInfo) {
+        //restore macro info if available
+        oSettings["_macroInfo"] = oPreviousMacroInfo;
+      } else {
+        delete oSettings["_macroInfo"];
+      }
+    } catch (e) {
+      // In case there is a generic error (usually code error), we retrieve the current context information and create a dedicated error message
+      const traceDetails = {
+        initialProperties: {},
+        resolvedProperties: {},
+        missingContexts: mMissingContext
+      };
+      for (const propertyName of initialKeys) {
+        const propertyValue = propertyValues[propertyName];
+        if (isContext(propertyValue)) {
+          traceDetails.initialProperties[propertyName] = {
+            path: propertyValue.getPath(),
+            value: propertyValue.getObject()
+          };
+        } else {
+          traceDetails.initialProperties[propertyName] = propertyValue;
+        }
+      }
+      for (const propertyName in propertyValues) {
+        const propertyValue = propertyValues[propertyName];
+        if (!initialKeys.includes(propertyName)) {
+          if (isContext(propertyValue)) {
+            traceDetails.resolvedProperties[propertyName] = {
+              path: propertyValue.getPath(),
+              value: propertyValue.getObject()
+            };
+          } else {
+            traceDetails.resolvedProperties[propertyName] = propertyValue;
+          }
+        }
+      }
+      Log.error(e);
+      const oError = createErrorXML([`Error while processing building block ${oMetadata.name}`], oNode.outerHTML, traceDetails, e.stack);
+      const oTemplate = parseXMLString(oError, true);
+      oNode.replaceWith(...oTemplate);
+    }
+  }
+  function addSingleContext(mContexts, oVisitor, oCtx) {
+    const sKey = oCtx.name || oCtx.model || undefined;
+    if (mContexts[sKey]) {
+      return; // do not add twice
+    }
+
+    try {
+      let sContextPath = oCtx.path;
+      if (oCtx.model !== null) {
+        sContextPath = `${oCtx.model}>${sContextPath}`;
+      }
+      const mSetting = oVisitor.getSettings();
+      if (oCtx.model === "converterContext" && oCtx.path.length > 0) {
+        mContexts[sKey] = mSetting.models[oCtx.model].getContext(oCtx.path /*, mSetting.bindingContexts[oCtx.model]*/); // add the context to the visitor
+      } else 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
+      }
+    } catch (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
+    }
+  }
+
+  /**
+   * Register a building block definition to be used inside the xml template processor.
+   *
+   * @param BuildingBlockClass The building block definition
+   */
+  function registerBuildingBlock(BuildingBlockClass) {
+    XMLPreprocessor.plugIn(async (oNode, oVisitor) => processBuildingBlock(BuildingBlockClass, oNode, oVisitor), BuildingBlockClass.metadata.namespace, BuildingBlockClass.metadata.xmlTag || BuildingBlockClass.metadata.name);
+    if (BuildingBlockClass.metadata.publicNamespace) {
+      XMLPreprocessor.plugIn(async (oNode, oVisitor) => processBuildingBlock(BuildingBlockClass, oNode, oVisitor, true), BuildingBlockClass.metadata.publicNamespace, BuildingBlockClass.metadata.xmlTag || BuildingBlockClass.metadata.name);
+    }
+  }
+
+  /**
+   * UnRegister a building block definition so that it is no longer used inside the xml template processor.
+   *
+   * @param BuildingBlockClass The building block definition
+   */
+  _exports.registerBuildingBlock = registerBuildingBlock;
+  function unregisterBuildingBlock(BuildingBlockClass) {
+    if (BuildingBlockClass.metadata.namespace !== undefined) {
+      XMLPreprocessor.plugIn(null, BuildingBlockClass.metadata.namespace, BuildingBlockClass.metadata.xmlTag || BuildingBlockClass.metadata.name);
+    }
+    if (BuildingBlockClass.metadata.publicNamespace !== undefined) {
+      XMLPreprocessor.plugIn(null, BuildingBlockClass.metadata.publicNamespace, BuildingBlockClass.metadata.xmlTag || BuildingBlockClass.metadata.name);
+    }
+  }
+  _exports.unregisterBuildingBlock = unregisterBuildingBlock;
+  function createErrorXML(errorMessages, xmlFragment, additionalData, stack) {
+    const errorLabels = errorMessages.map(errorMessage => xml`<m:Label text="${escapeXMLAttributeValue(errorMessage)}"/>`);
+    let errorStack = "";
+    if (stack) {
+      const stackFormatted = btoa(`<pre>${stack}</pre>`);
+      errorStack = xml`<m:FormattedText htmlText="${`{= BBF.base64Decode('${stackFormatted}') }`}" />`;
+    }
+    let additionalText = "";
+    if (additionalData) {
+      additionalText = xml`<m:VBox>
+						<m:Label text="Trace Info"/>
+						<code:CodeEditor type="json"  value="${`{= BBF.base64Decode('${btoa(JSON.stringify(additionalData, null, 4))}') }`}" height="300px" />
+					</m:VBox>`;
+    }
+    return xml`<controls:FormElementWrapper xmlns:controls="sap.fe.core.controls">
+					<m:VBox xmlns:m="sap.m" xmlns:code="sap.ui.codeeditor" core:require="{BBF:'sap/fe/core/buildingBlocks/BuildingBlockFormatter'}">
+					${errorLabels}
+					${errorStack}
+						<grid:CSSGrid gridTemplateRows="fr" gridTemplateColumns="repeat(2,1fr)" gridGap="1rem" xmlns:grid="sap.ui.layout.cssgrid" >
+							<m:VBox>
+								<m:Label text="How the building block was called"/>
+								<code:CodeEditor type="xml" value="${`{= BBF.base64Decode('${btoa(xmlFragment.replaceAll("&gt;", ">"))}') }`}" height="300px" />
+							</m:VBox>
+							${additionalText}
+						</grid:CSSGrid>
+					</m:VBox>
+				</controls:FormElementWrapper>`;
+  }
+  const temporaryObjectStore = {};
+
+  /**
+   * Stores an object value in a temporary storage and returns an ID used to retrieve this value at a later point in time.
+   *
+   * Required as there is functionality like the xml` function, which might take objects as parameters but needs to return a serialized string.
+   *
+   * @param value Value to store
+   * @returns ID to retrieve this value
+   */
+  function storeObjectValue(value) {
+    const propertyUID = `/uid--${uid()}`;
+    temporaryObjectStore[propertyUID] = value;
+    return propertyUID;
+  }
+
+  /**
+   * Unstores an object from a temporary store by removing it and returning its object value.
+   *
+   * @param propertyUID ID to retrieve this value
+   * @returns Object value
+   */
+  function unstoreObjectValue(propertyUID) {
+    const value = temporaryObjectStore[propertyUID];
+    delete temporaryObjectStore[propertyUID];
+    return value;
+  }
+  let processNextXmlInTrace = false;
+  /**
+   * Makes sure that all xml` calls inside the given method are processed in trace mode.
+   *
+   * @param method The method to execute
+   * @returns The return value of the given method
+   */
+  const processXmlInTrace = function (method) {
+    processNextXmlInTrace = true;
+    let returnValue;
+    try {
+      returnValue = method();
+    } finally {
+      processNextXmlInTrace = false;
+    }
+    return returnValue;
+  };
+
+  /**
+   * Parse an XML string and return the associated document.
+   *
+   * @param xmlString The xml string
+   * @param [addDefaultNamespaces] Whether or not default namespaces should be added
+   * @returns The XML document.
+   */
+  function parseXMLString(xmlString) {
+    var _output2, _output3;
+    let addDefaultNamespaces = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    if (addDefaultNamespaces) {
+      xmlString = `<template
+						xmlns:template="http://schemas.sap.com/sapui5/extension/sap.ui.core.template/1"
+						xmlns:m="sap.m"
+						xmlns:macros="sap.fe.macros"
+						xmlns:core="sap.ui.core"
+						xmlns:mdc="sap.ui.mdc"
+						xmlns:customData="http://schemas.sap.com/sapui5/extension/sap.ui.core.CustomData/1">${xmlString}</template>`;
+    }
+    const xmlDocument = DOMParserInstance.parseFromString(xmlString, "text/xml");
+    let output = xmlDocument.firstElementChild;
+    while (((_output = output) === null || _output === void 0 ? void 0 : _output.localName) === "template") {
+      var _output;
+      output = output.firstElementChild;
+    }
+    const children = (_output2 = output) !== null && _output2 !== void 0 && _output2.parentElement ? (_output3 = output) === null || _output3 === void 0 ? void 0 : _output3.parentElement.children : [output];
+    return Array.from(children);
+  }
+
+  /**
+   * Escape an XML attribute value.
+   *
+   * @param value The attribute value to escape.
+   * @returns The escaped string.
+   */
+  _exports.parseXMLString = parseXMLString;
+  function escapeXMLAttributeValue(value) {
+    return value === null || value === void 0 ? void 0 : value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  }
+  _exports.escapeXMLAttributeValue = escapeXMLAttributeValue;
+  function renderInTraceMode(outStr) {
+    var _xmlResult$;
+    const xmlResult = parseXMLString(outStr, true);
+    if ((xmlResult === null || xmlResult === void 0 ? void 0 : xmlResult.length) > 0 && ((_xmlResult$ = xmlResult[0]) === null || _xmlResult$ === void 0 ? void 0 : _xmlResult$.localName) === "parsererror") {
+      const errorMessage = xmlResult[0].innerText || xmlResult[0].innerHTML;
+      return createErrorXML([errorMessage.split("\n")[0]], outStr);
+    } else {
+      return outStr;
+    }
+  }
+  /**
+   * 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.
+   */
+  const xml = function (strings) {
+    let outStr = "";
+    let 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++) {
+      outStr += strings[i];
+
+      // Handle the different case of object, if it's an array we join them, if it's a binding expression then we compile it.
+      const value = values[i];
+      if (Array.isArray(value) && value.length > 0 && typeof value[0] === "string") {
+        outStr += value.flat(5).join("\n").trim();
+      } else if (isFunctionArray(value)) {
+        outStr += value.map(valuefn => valuefn()).join("\n");
+      } else if (isBindingToolkitExpression(value)) {
+        const compiledExpression = compileExpression(value);
+        outStr += escapeXMLAttributeValue(compiledExpression);
+      } else if (typeof value === "undefined") {
+        outStr += "{this>undefinedValue}";
+      } else if (typeof value === "function") {
+        outStr += value();
+      } else if (typeof value === "object" && value !== null) {
+        if (isContext(value)) {
+          outStr += value.getPath();
+        } else {
+          const propertyUId = storeObjectValue(value);
+          outStr += `${propertyUId}`;
+        }
+      } else if (value && typeof value === "string" && !value.startsWith("<") && !value.startsWith("&lt;")) {
+        outStr += escapeXMLAttributeValue(value);
+      } else {
+        outStr += value;
+      }
+    }
+    outStr += strings[i];
+    outStr = outStr.trim();
+    if (processNextXmlInTrace) {
+      return renderInTraceMode(outStr);
+    }
+    return outStr;
+  };
+  _exports.xml = xml;
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["LOGGER_SCOPE","XMLTEMPLATING_NS","DOMParserInstance","DOMParser","validateMacroMetadataContext","sName","mContexts","oContextSettings","sKey","oContext","oContextObject","getObject","required","Error","hasOwnProperty","$kind","undefined","indexOf","getPath","$Type","validateMacroSignature","oMetadata","oNode","aMetadataContextKeys","metadataContexts","Object","keys","aProperties","properties","oAttributeNames","attributeNames","getAttributeNames","attributeName","forEach","oPropertySettings","hasAttribute","startsWith","Log","warning","SAP_UI_CORE_ELEMENT","SAP_UI_MODEL_CONTEXT","transformMetadata","buildingBlockMetadata","aggregations","dependents","type","slot","customData","propertyName","propertyType","includes","_checkAbsoluteAndContextPaths","oSettings","sAttributeValue","sMetaPath","sContextPath","currentContextPath","endsWith","model","path","_createInitialMetadataContext","sAttributeName","returnContext","models","converterContext","getProperty","data","unstoreObjectValue","setProperty","bindingContexts","entitySet","_getMetadataContext","oVisitor","bDoNotResolve","isOpen","oMetadataContext","getAttribute","BindingParser","complexParser","getContext","e","processProperties","isPublic","oDefinitionProperties","aDefinitionPropertiesKeys","propertyValues","sKeyValue","defaultValue","deepClone","error","visitAttribute","attributes","getNamedItem","value","Number","processContexts","contextPath","mMissingContext","oDefinitionContexts","aDefinitionContextsKeys","contextPathIndex","contextPathDefinition","splice","propertyValue","length","name","addSingleContext","parseAggregation","oAggregation","processAggregations","oOutObjects","children","childIdx","childDefinition","childKey","setAttribute","aggregationObject","key","position","placement","Placement","After","anchor","tagName","nodeName","processChildren","oAggregations","firstElementChild","oFirstElementChild","namespaceURI","oParent","parentNode","iChildIndex","Array","from","visitNode","nextElementSibling","sChildName","localName","sAggregationName","toUpperCase","defaultAggregation","aggregationDefinition","parsedAggregation","parsedAggregationKey","oNextChild","nextChild","hasVirtualNode","childWrapper","document","createElementNS","appendChild","removeAttribute","oNewChild","aggregationPropertyValues","childIndex","subChild","subObjectKey","subObject","subChildAttributeNames","subChildAttributeName","myChild","push","processSlots","oMetadataAggregations","processCustomData","oAggregationElement","oElementChild","sSlotName","oTargetElement","querySelector","prepareAggregationElement","replaceWith","replace","processBuildingBlock","BuildingBlockClass","metadata","sFragmentName","fragment","namespace","xmlTag","getSettings","JSONModel","initialKeys","oControlConfig","viewData","processedPropertyValues","propName","oData","originalDefinition","validate","isA","getModel","oInstance","getProperties","sContextName","targetObject","isContext","attributeValue","storeObjectValue","newContext","createBindingContext","oAttributesModel","AttributeModel","oPreviousMacroInfo","TraceInfo","isTraceInfoActive","oTraceInfo","traceMacroCalls","macroInfo","oContextVisitor","with","oPromise","insertFragment","templateString","getTemplate","isRuntime","storeKey","temporaryObjectStore","hasError","hasParseError","parsedTemplate","parseXMLString","element","iter","createNodeIterator","NodeFilter","SHOW_TEXT","textnode","nextNode","textContent","trim","processXmlInTrace","initialTemplate","oErrorText","createErrorXML","map","template","outerHTML","join","remove","Promise","resolve","oMacroElement","oRemainingSlots","querySelectorAll","oSlotElement","traceDetails","initialProperties","resolvedProperties","missingContexts","oError","stack","oTemplate","oCtx","mSetting","ex","registerBuildingBlock","XMLPreprocessor","plugIn","publicNamespace","unregisterBuildingBlock","errorMessages","xmlFragment","additionalData","errorLabels","errorMessage","xml","escapeXMLAttributeValue","errorStack","stackFormatted","btoa","additionalText","JSON","stringify","replaceAll","propertyUID","uid","processNextXmlInTrace","method","returnValue","xmlString","addDefaultNamespaces","xmlDocument","parseFromString","output","parentElement","renderInTraceMode","outStr","xmlResult","innerText","innerHTML","split","strings","i","values","isArray","flat","isFunctionArray","valuefn","isBindingToolkitExpression","compiledExpression","compileExpression","propertyUId"],"sourceRoot":".","sources":["BuildingBlockTemplateProcessor.ts"],"sourcesContent":["import Log from \"sap/base/Log\";\nimport deepClone from \"sap/base/util/deepClone\";\nimport uid from \"sap/base/util/uid\";\nimport type AppComponent from \"sap/fe/core/AppComponent\";\nimport AttributeModel from \"sap/fe/core/buildingBlocks/AttributeModel\";\nimport type BuildingBlockBase from \"sap/fe/core/buildingBlocks/BuildingBlockBase\";\nimport type {\n\tBuildingBlockAggregationDefinition,\n\tBuildingBlockMetadata,\n\tBuildingBlockMetadataContextDefinition,\n\tBuildingBlockPropertyDefinition,\n\tObjectValue,\n\tObjectValue2\n} from \"sap/fe/core/buildingBlocks/BuildingBlockSupport\";\nimport type { Position } from \"sap/fe/core/converters/helpers/ConfigurableObject\";\nimport { Placement } from \"sap/fe/core/converters/helpers/ConfigurableObject\";\nimport type { BindingToolkitExpression } from \"sap/fe/core/helpers/BindingToolkit\";\nimport { compileExpression, isBindingToolkitExpression } from \"sap/fe/core/helpers/BindingToolkit\";\nimport { isContext, isFunctionArray } from \"sap/fe/core/helpers/TypeGuards\";\nimport type ResourceModel from \"sap/fe/core/ResourceModel\";\nimport BindingParser from \"sap/ui/base/BindingParser\";\nimport type Control from \"sap/ui/core/Control\";\nimport XMLPreprocessor from \"sap/ui/core/util/XMLPreprocessor\";\nimport type Context from \"sap/ui/model/Context\";\nimport JSONModel from \"sap/ui/model/json/JSONModel\";\nimport type Model from \"sap/ui/model/Model\";\nimport type ODataMetaModel from \"sap/ui/model/odata/v4/ODataMetaModel\";\nimport type { MacroInfo, TraceMetadataContext } from \"./TraceInfo\";\nimport TraceInfo from \"./TraceInfo\";\n\nconst LOGGER_SCOPE = \"sap.fe.core.buildingBlocks.BuildingBlockTemplateProcessor\";\nconst XMLTEMPLATING_NS = \"http://schemas.sap.com/sapui5/extension/sap.ui.core.template/1\";\nconst DOMParserInstance = new DOMParser();\n\nexport type TransformedBuildingBlockMetadata = BuildingBlockMetadata & {\n\tmetadataContexts: Record<string, BuildingBlockMetadataContextDefinition>;\n};\n\n/**\n * Definition of a meta data context\n */\ntype MetaDataContext = {\n\tname?: string;\n\tmodel: string;\n\tpath: string;\n};\n\nexport type TemplateProcessorSettings = {\n\tcurrentContextPath: Context;\n\tisPublic: boolean;\n\tappComponent: AppComponent;\n\tmodels: Record<string, Model> & {\n\t\tconverterContext: JSONModel;\n\t\tviewData: JSONModel;\n\t\tmetaModel: ODataMetaModel;\n\t\t\"sap.fe.i18n\"?: ResourceModel;\n\t};\n\tbindingContexts: Record<string, Context>;\n\t_macroInfo?: MacroInfo;\n\t[k: string]: unknown;\n};\n\nexport type IVisitorCallback = {\n\tgetSettings(): TemplateProcessorSettings;\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 oNode\n\t *   The XML DOM node\n\t * @returns\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 sFragment\n\t *   the fragment's resolved name\n\t * @param oElement\n\t *   the XML DOM element, e.g. <sap.ui.core:Fragment> or <core:ExtensionPoint>\n\t * @param oWith\n\t *   the parent's \"with\" control\n\t * @returns\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?: Control): Promise<void>;\n\tvisitAttribute(oNode: Element, oAttribute: Attr): Promise<void>;\n\tvisitAttributes(oNode: Element): Promise<void>;\n\tgetViewInfo(): Promise<unknown>;\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 *\n\t * @param sValue\n\t *   An XML DOM attribute value\n\t * @param [element]\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\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<Context> | null;\n\tgetContext(sPath?: string): Context | undefined;\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 [mVariables={}]\n\t *   Map from variable name (string) to value\n\t * @param [bReplace]\n\t *   Whether only the given variables are known in the new callback interface\n\t *   instance, no inherited ones\n\t * @returns\n\t *   A callback interface instance\n\t * @param mVariables\n\t * @param bReplace\n\t */\n\t\"with\"(mVariables?: Record<string, Context>, bReplace?: boolean): IVisitorCallback;\n};\n\nfunction validateMacroMetadataContext(\n\tsName: string,\n\tmContexts: Record<string, Context>,\n\toContextSettings: BuildingBlockMetadataContextDefinition,\n\tsKey: string\n) {\n\tconst oContext = mContexts[sKey];\n\tconst oContextObject = oContext?.getObject() as {\n\t\t$Type?: string;\n\t\t$kind?: string;\n\t};\n\n\tif (oContextSettings.required === true && (!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\") && oContextObject.$kind !== undefined && oContextSettings.$kind !== undefined) {\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\") && oContextObject.$Type !== undefined && 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(\n\tsName: string,\n\toMetadata: TransformedBuildingBlockMetadata,\n\tmContexts: Record<string, Context>,\n\toNode: Element\n) {\n\tconst aMetadataContextKeys = (oMetadata.metadataContexts && Object.keys(oMetadata.metadataContexts)) || [],\n\t\taProperties = (oMetadata.properties && Object.keys(oMetadata.properties)) || [],\n\t\toAttributeNames: Record<string, boolean> = {};\n\n\t// collect all attributes to find unchecked properties\n\tconst attributeNames = oNode.getAttributeNames();\n\tfor (const attributeName of attributeNames) {\n\t\toAttributeNames[attributeName] = true;\n\t}\n\n\t//Check metadataContexts\n\taMetadataContextKeys.forEach(function (sKey) {\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) {\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 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\nconst SAP_UI_CORE_ELEMENT = \"sap.ui.core.Element\";\n\nexport const SAP_UI_MODEL_CONTEXT = \"sap.ui.model.Context\";\n\n/**\n * Transforms the metadata of a building block by adding additional aggregations,\n * and splitting properties into actual properties and metadata contexts.\n *\n * @param buildingBlockMetadata The metadata received from the input\n * @returns The transformed metadata\n */\nfunction transformMetadata(buildingBlockMetadata: BuildingBlockMetadata): TransformedBuildingBlockMetadata {\n\tconst properties: Record<string, BuildingBlockPropertyDefinition> = {};\n\tconst aggregations: Record<string, BuildingBlockAggregationDefinition> = {\n\t\tdependents: {\n\t\t\ttype: SAP_UI_CORE_ELEMENT,\n\t\t\tslot: \"dependents\"\n\t\t},\n\t\tcustomData: {\n\t\t\ttype: SAP_UI_CORE_ELEMENT,\n\t\t\tslot: \"customData\"\n\t\t},\n\t\t...buildingBlockMetadata.aggregations\n\t};\n\tconst metadataContexts: Record<string, BuildingBlockPropertyDefinition> = {};\n\n\tfor (const propertyName of Object.keys(buildingBlockMetadata.properties)) {\n\t\tconst propertyType = buildingBlockMetadata.properties[propertyName].type;\n\n\t\tif (propertyType !== SAP_UI_MODEL_CONTEXT) {\n\t\t\tproperties[propertyName] = buildingBlockMetadata.properties[propertyName];\n\t\t}\n\n\t\tif ([SAP_UI_MODEL_CONTEXT, \"object\", \"array\"].includes(propertyType)) {\n\t\t\t// Explicitly defined contexts, objects, and arrays may come from the metadataContext\n\t\t\tmetadataContexts[propertyName] = buildingBlockMetadata.properties[propertyName];\n\t\t}\n\t}\n\n\treturn {\n\t\t...buildingBlockMetadata,\n\t\tproperties,\n\t\tmetadataContexts,\n\t\taggregations\n\t};\n}\n\n/**\n * Checks the absolute or context paths and returns an appropriate MetaContext.\n *\n * @param oSettings Additional settings\n * @param sAttributeValue The attribute value\n * @returns The meta data context object\n */\nfunction _checkAbsoluteAndContextPaths(oSettings: TemplateProcessorSettings, sAttributeValue: string): MetaDataContext {\n\tlet sMetaPath: string;\n\tif (sAttributeValue && sAttributeValue.startsWith(\"/\")) {\n\t\t// absolute path - we just use this one\n\t\tsMetaPath = sAttributeValue;\n\t} else {\n\t\tlet sContextPath = oSettings.currentContextPath.getPath();\n\t\tif (!sContextPath.endsWith(\"/\")) {\n\t\t\tsContextPath += \"/\";\n\t\t}\n\t\tsMetaPath = sContextPath + sAttributeValue;\n\t}\n\treturn {\n\t\tmodel: \"metaModel\",\n\t\tpath: sMetaPath\n\t};\n}\n\n/**\n * This method helps to create the metadata context in case it is not yet available in the store.\n *\n * @param oSettings Additional settings\n * @param sAttributeName The attribute name\n * @param sAttributeValue The attribute value\n * @returns The meta data context object\n */\nfunction _createInitialMetadataContext(\n\toSettings: TemplateProcessorSettings,\n\tsAttributeName: string,\n\tsAttributeValue: string\n): MetaDataContext {\n\tlet returnContext: MetaDataContext;\n\tif (sAttributeValue.startsWith(\"/uid--\") && !oSettings.models.converterContext.getProperty(sAttributeValue)) {\n\t\tconst data = unstoreObjectValue(sAttributeValue);\n\t\toSettings.models.converterContext.setProperty(sAttributeValue, data);\n\t\treturnContext = {\n\t\t\tmodel: \"converterContext\",\n\t\t\tpath: sAttributeValue\n\t\t};\n\t} else if ((sAttributeName === \"metaPath\" && oSettings.currentContextPath) || sAttributeName === \"contextPath\") {\n\t\treturnContext = _checkAbsoluteAndContextPaths(oSettings, sAttributeValue);\n\t} else if (sAttributeValue && sAttributeValue.startsWith(\"/\")) {\n\t\t// absolute path - we just use this one\n\t\treturnContext = {\n\t\t\tmodel: \"metaModel\",\n\t\t\tpath: sAttributeValue\n\t\t};\n\t} else {\n\t\treturnContext = {\n\t\t\tmodel: \"metaModel\",\n\t\t\tpath: oSettings.bindingContexts.entitySet ? oSettings.bindingContexts.entitySet.getPath(sAttributeValue) : sAttributeValue\n\t\t};\n\t}\n\treturn returnContext;\n}\n\nfunction _getMetadataContext(\n\toSettings: TemplateProcessorSettings,\n\toNode: Element,\n\tsAttributeName: string,\n\toVisitor: IVisitorCallback,\n\tbDoNotResolve: boolean,\n\tisOpen: boolean\n) {\n\tlet oMetadataContext: MetaDataContext | undefined;\n\tif (!bDoNotResolve && oNode.hasAttribute(sAttributeName)) {\n\t\tconst sAttributeValue = oNode.getAttribute(sAttributeName) as string;\n\t\toMetadataContext = BindingParser.complexParser(sAttributeValue);\n\t\tif (!oMetadataContext) {\n\t\t\toMetadataContext = _createInitialMetadataContext(oSettings, sAttributeName, sAttributeValue);\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\treturn undefined;\n\t\t}\n\t}\n\treturn oMetadataContext;\n}\n\n/**\n * Parse the incoming XML node and try to resolve the properties defined there.\n *\n * @param oMetadata The metadata for the building block\n * @param oNode The XML node to parse\n * @param isPublic Whether the building block is used in a public context or not\n * @param oVisitor The visitor instance\n */\nasync function processProperties(\n\toMetadata: TransformedBuildingBlockMetadata,\n\toNode: Element,\n\tisPublic: boolean,\n\toVisitor: IVisitorCallback\n) {\n\tconst oDefinitionProperties = oMetadata.properties;\n\n\t// Retrieve properties values\n\tconst aDefinitionPropertiesKeys = Object.keys(oDefinitionProperties);\n\n\tconst propertyValues: Record<string, ObjectValue> = {};\n\tfor (const sKeyValue of aDefinitionPropertiesKeys) {\n\t\tif (oDefinitionProperties[sKeyValue].type === \"object\") {\n\t\t\tpropertyValues[sKeyValue] =\n\t\t\t\toDefinitionProperties[sKeyValue].defaultValue && deepClone(oDefinitionProperties[sKeyValue].defaultValue); // To avoid values being reused across macros\n\t\t} else {\n\t\t\tpropertyValues[sKeyValue] = oDefinitionProperties[sKeyValue].defaultValue as string | boolean | number;\n\t\t}\n\n\t\tif (oNode.hasAttribute(sKeyValue) && isPublic && oDefinitionProperties[sKeyValue].isPublic === false) {\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\tlet value: string | boolean | number | null | undefined = oNode.getAttribute(sKeyValue);\n\t\t\tif (value !== undefined && value !== null) {\n\t\t\t\tif (typeof value === \"string\" && !value.startsWith(\"{\")) {\n\t\t\t\t\tswitch (oDefinitionProperties[sKeyValue].type) {\n\t\t\t\t\t\tcase \"boolean\":\n\t\t\t\t\t\t\tvalue = value === \"true\";\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase \"number\":\n\t\t\t\t\t\t\tvalue = Number(value);\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tvalue = value === null ? undefined : value;\n\t\t\t\tpropertyValues[sKeyValue] = value;\n\t\t\t}\n\t\t}\n\t}\n\treturn propertyValues;\n}\n\n/**\n * Parse the incoming XML node and try to resolve the binding contexts defined inside.\n *\n * @param oMetadata The metadata for the building block\n * @param oSettings The settings object\n * @param oNode The XML node to parse\n * @param isPublic Whether the building block is used in a public context or not\n * @param oVisitor The visitor instance\n * @param mContexts The contexts to be used\n * @param propertyValues The current property values\n * @returns The processed and missing contexts\n */\nfunction processContexts(\n\toMetadata: TransformedBuildingBlockMetadata,\n\toSettings: TemplateProcessorSettings,\n\toNode: Element,\n\tisPublic: boolean,\n\toVisitor: IVisitorCallback,\n\tmContexts: Record<string, Context>,\n\tpropertyValues: Record<string, ObjectValue>\n) {\n\toSettings.currentContextPath = oSettings.bindingContexts.contextPath;\n\tconst mMissingContext: Record<string, boolean> = {};\n\tconst oDefinitionContexts = oMetadata.metadataContexts;\n\tconst aDefinitionContextsKeys = Object.keys(oDefinitionContexts);\n\t// Since the metaPath and other property can be relative to the contextPath we need to evaluate the current contextPath first\n\tconst contextPathIndex = aDefinitionContextsKeys.indexOf(\"contextPath\");\n\tif (contextPathIndex !== -1) {\n\t\t// If it is defined we extract it and reinsert it in the first position of the array\n\t\tconst contextPathDefinition = aDefinitionContextsKeys.splice(contextPathIndex, 1);\n\t\taDefinitionContextsKeys.splice(0, 0, contextPathDefinition[0]);\n\t}\n\tfor (const sAttributeName of aDefinitionContextsKeys) {\n\t\t// If the context was resolved as a property (binding / xml aggregation) then we don't need to resolve it here.\n\t\tconst propertyValue = propertyValues[sAttributeName];\n\t\tif (propertyValue !== undefined && typeof propertyValue === \"object\" && Object.keys(propertyValue as object).length > 0) {\n\t\t\tdelete oMetadata.metadataContexts[sAttributeName];\n\t\t\tcontinue;\n\t\t}\n\t\tconst bDoNotResolve = isPublic && oDefinitionContexts[sAttributeName].isPublic === false && oNode.hasAttribute(sAttributeName);\n\t\tconst oMetadataContext = _getMetadataContext(oSettings, oNode, sAttributeName, oVisitor, bDoNotResolve, oMetadata.isOpen ?? false);\n\t\tif (oMetadataContext) {\n\t\t\toMetadataContext.name = sAttributeName;\n\t\t\taddSingleContext(mContexts, oVisitor, oMetadataContext);\n\t\t\tif (\n\t\t\t\t(sAttributeName === \"entitySet\" || sAttributeName === \"contextPath\") &&\n\t\t\t\t!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\tif (mContexts[sAttributeName] !== undefined) {\n\t\t\t\tpropertyValues[sAttributeName] = mContexts[sAttributeName];\n\t\t\t} else if (typeof propertyValues[sAttributeName] === \"string\") {\n\t\t\t\t// If the binding couldn't be resolved consider that there was no value here\n\t\t\t\tdelete oMetadata.metadataContexts[sAttributeName];\n\t\t\t}\n\t\t} else {\n\t\t\tmMissingContext[sAttributeName] = true;\n\t\t}\n\t}\n\treturn mMissingContext;\n}\n\nexport type BuildingBlockAggregation = {\n\tkey: string;\n\tposition: Position;\n\ttype: \"Slot\";\n};\nfunction parseAggregation(oAggregation?: Element, processAggregations?: Function) {\n\tconst oOutObjects: Record<string, BuildingBlockAggregation> = {};\n\tif (oAggregation && oAggregation.children.length > 0) {\n\t\tconst children = oAggregation.children;\n\t\tfor (let childIdx = 0; childIdx < children.length; childIdx++) {\n\t\t\tconst childDefinition = children[childIdx];\n\t\t\tlet childKey = childDefinition.getAttribute(\"key\") || childDefinition.getAttribute(\"id\");\n\t\t\tif (childKey) {\n\t\t\t\tchildKey = `InlineXML_${childKey}`;\n\t\t\t\tchildDefinition.setAttribute(\"key\", childKey);\n\t\t\t\tlet aggregationObject: BuildingBlockAggregation = {\n\t\t\t\t\tkey: childKey,\n\t\t\t\t\tposition: {\n\t\t\t\t\t\tplacement: (childDefinition.getAttribute(\"placement\") as Placement) || Placement.After,\n\t\t\t\t\t\tanchor: childDefinition.getAttribute(\"anchor\") || undefined\n\t\t\t\t\t},\n\t\t\t\t\ttype: \"Slot\"\n\t\t\t\t};\n\t\t\t\tif (processAggregations) {\n\t\t\t\t\taggregationObject = processAggregations(childDefinition, aggregationObject);\n\t\t\t\t}\n\t\t\t\toOutObjects[aggregationObject.key] = aggregationObject;\n\t\t\t} else if (childDefinition.tagName !== \"slot\") {\n\t\t\t\tLog.error(`The aggregation ${childDefinition.nodeName} is missing a Key attribute. It is not displayed`);\n\t\t\t}\n\t\t}\n\t}\n\treturn oOutObjects;\n}\n\n/**\n * Processes the child nodes of the building block and parses them as either aggregations or object-/array-based values.\n *\n * @param oNode The XML node for which to process the children\n * @param oVisitor The visitor instance\n * @param oMetadata The metadata for the building block\n * @param isPublic Whether the building block is used in a public context or not\n * @param propertyValues The values of already parsed property\n */\nasync function processChildren(\n\toNode: Element,\n\toVisitor: IVisitorCallback,\n\toMetadata: TransformedBuildingBlockMetadata,\n\tisPublic: boolean,\n\tpropertyValues: Record<string, ObjectValue>\n) {\n\tconst oAggregations: Record<string, Element> = {};\n\tif (oNode.firstElementChild !== null) {\n\t\tlet oFirstElementChild: Element | null = oNode.firstElementChild as Element | null;\n\n\t\twhile (oFirstElementChild !== null) {\n\t\t\tif (oFirstElementChild.namespaceURI === XMLTEMPLATING_NS) {\n\t\t\t\t// In case we encounter a templating tag, run the visitor on it and continue with the resulting child\n\t\t\t\tconst oParent = oFirstElementChild.parentNode;\n\t\t\t\tif (oParent) {\n\t\t\t\t\tconst iChildIndex = Array.from(oParent.children).indexOf(oFirstElementChild);\n\t\t\t\t\tawait oVisitor.visitNode(oFirstElementChild);\n\t\t\t\t\toFirstElementChild = oParent.children[iChildIndex] ? oParent.children[iChildIndex] : null;\n\t\t\t\t} else {\n\t\t\t\t\t// Not sure how this could happen but I also don't want to create infinite loops\n\t\t\t\t\toFirstElementChild = oFirstElementChild.nextElementSibling;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tconst sChildName = oFirstElementChild.localName;\n\t\t\t\tlet sAggregationName = sChildName;\n\t\t\t\tif (sAggregationName[0].toUpperCase() === sAggregationName[0]) {\n\t\t\t\t\t// not a sub aggregation, go back to default Aggregation\n\t\t\t\t\tsAggregationName = oMetadata.defaultAggregation || \"\";\n\t\t\t\t}\n\t\t\t\tconst aggregationDefinition = oMetadata.aggregations[sAggregationName];\n\t\t\t\tif (aggregationDefinition !== undefined && !aggregationDefinition.slot) {\n\t\t\t\t\tconst parsedAggregation = parseAggregation(oFirstElementChild, aggregationDefinition.processAggregations);\n\t\t\t\t\tpropertyValues[sAggregationName] = parsedAggregation;\n\t\t\t\t\tfor (const parsedAggregationKey in parsedAggregation) {\n\t\t\t\t\t\toMetadata.aggregations[parsedAggregationKey] = parsedAggregation[parsedAggregationKey];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\toFirstElementChild = oFirstElementChild.nextElementSibling;\n\t\t\t}\n\t\t}\n\n\t\toFirstElementChild = oNode.firstElementChild;\n\t\twhile (oFirstElementChild !== null) {\n\t\t\tconst oNextChild: Element | null = oFirstElementChild.nextElementSibling;\n\t\t\tconst sChildName = oFirstElementChild.localName;\n\t\t\tlet sAggregationName = sChildName;\n\t\t\tif (sAggregationName[0].toUpperCase() === sAggregationName[0]) {\n\t\t\t\t// not a sub aggregation, go back to default Aggregation\n\t\t\t\tsAggregationName = oMetadata.defaultAggregation || \"\";\n\t\t\t}\n\t\t\tif (\n\t\t\t\tObject.keys(oMetadata.aggregations).indexOf(sAggregationName) !== -1 &&\n\t\t\t\t(!isPublic || oMetadata.aggregations[sAggregationName].isPublic === true)\n\t\t\t) {\n\t\t\t\tconst aggregationDefinition = oMetadata.aggregations[sAggregationName];\n\t\t\t\tif (!aggregationDefinition.slot && oFirstElementChild !== null && oFirstElementChild.children.length > 0) {\n\t\t\t\t\tawait oVisitor.visitNode(oFirstElementChild);\n\t\t\t\t\tlet childDefinition = oFirstElementChild.firstElementChild;\n\t\t\t\t\twhile (childDefinition) {\n\t\t\t\t\t\tconst nextChild = childDefinition.nextElementSibling;\n\t\t\t\t\t\tif (!aggregationDefinition.hasVirtualNode) {\n\t\t\t\t\t\t\tconst childWrapper = document.createElementNS(oNode.namespaceURI, childDefinition.getAttribute(\"key\")!);\n\t\t\t\t\t\t\tchildWrapper.appendChild(childDefinition);\n\t\t\t\t\t\t\toAggregations[childDefinition.getAttribute(\"key\")!] = childWrapper;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\toAggregations[childDefinition.getAttribute(\"key\")!] = childDefinition;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tchildDefinition.removeAttribute(\"key\");\n\t\t\t\t\t\tchildDefinition = nextChild;\n\t\t\t\t\t}\n\t\t\t\t} else if (aggregationDefinition.slot) {\n\t\t\t\t\tawait oVisitor.visitNode(oFirstElementChild);\n\t\t\t\t\tif (sAggregationName !== sChildName) {\n\t\t\t\t\t\tif (!oAggregations[sAggregationName]) {\n\t\t\t\t\t\t\tconst oNewChild = document.createElementNS(oNode.namespaceURI, sAggregationName);\n\t\t\t\t\t\t\toAggregations[sAggregationName] = oNewChild;\n\t\t\t\t\t\t}\n\t\t\t\t\t\toAggregations[sAggregationName].appendChild(oFirstElementChild);\n\t\t\t\t\t} else {\n\t\t\t\t\t\toAggregations[sAggregationName] = oFirstElementChild;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (Object.keys(oMetadata.properties).indexOf(sAggregationName) !== -1) {\n\t\t\t\tawait oVisitor.visitNode(oFirstElementChild);\n\t\t\t\tif (oMetadata.properties[sAggregationName].type === \"object\") {\n\t\t\t\t\t// Object Type properties\n\t\t\t\t\tconst aggregationPropertyValues: Record<string, ObjectValue2 | Record<string, ObjectValue2>> = {};\n\t\t\t\t\tconst attributeNames = oFirstElementChild.getAttributeNames();\n\t\t\t\t\tfor (const attributeName of attributeNames) {\n\t\t\t\t\t\taggregationPropertyValues[attributeName] = oFirstElementChild.getAttribute(attributeName);\n\t\t\t\t\t}\n\t\t\t\t\tif (oFirstElementChild.children.length) {\n\t\t\t\t\t\t//retrieve one level subObject properties\n\t\t\t\t\t\tfor (let childIndex = 0; childIndex < oFirstElementChild.children.length; childIndex++) {\n\t\t\t\t\t\t\tconst subChild = oFirstElementChild.children[childIndex];\n\t\t\t\t\t\t\tconst subObjectKey = subChild.localName;\n\t\t\t\t\t\t\tconst subObject: Record<string, ObjectValue2> = {};\n\t\t\t\t\t\t\tconst subChildAttributeNames = subChild.getAttributeNames();\n\t\t\t\t\t\t\tfor (const subChildAttributeName of subChildAttributeNames) {\n\t\t\t\t\t\t\t\tsubObject[subChildAttributeName] = subChild.getAttribute(subChildAttributeName);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\taggregationPropertyValues[subObjectKey] = subObject;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tpropertyValues[sAggregationName] = aggregationPropertyValues;\n\t\t\t\t} else if (oMetadata.properties[sAggregationName].type === \"array\") {\n\t\t\t\t\tif (oFirstElementChild !== null && oFirstElementChild.children.length > 0) {\n\t\t\t\t\t\tconst children = oFirstElementChild.children;\n\t\t\t\t\t\tconst oOutObjects: Record<string, ObjectValue2>[] = [];\n\t\t\t\t\t\tfor (let childIdx = 0; childIdx < children.length; childIdx++) {\n\t\t\t\t\t\t\tconst childDefinition = children[childIdx];\n\t\t\t\t\t\t\t// non keyed child, just add it to the aggregation\n\t\t\t\t\t\t\tconst myChild: Record<string, ObjectValue2> = {};\n\t\t\t\t\t\t\tconst attributeNames = childDefinition.getAttributeNames();\n\t\t\t\t\t\t\tfor (const attributeName of attributeNames) {\n\t\t\t\t\t\t\t\tmyChild[attributeName] = childDefinition.getAttribute(attributeName);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\toOutObjects.push(myChild);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tpropertyValues[sAggregationName] = oOutObjects;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\toFirstElementChild = oNextChild;\n\t\t}\n\t}\n\treturn oAggregations;\n}\n\nfunction processSlots(\n\toAggregations: Record<string, Element>,\n\toMetadataAggregations: Record<string, BuildingBlockAggregationDefinition>,\n\toNode: Element,\n\tprocessCustomData = false\n) {\n\tif (Object.keys(oAggregations).length > 0) {\n\t\tObject.keys(oAggregations).forEach(function (sAggregationName: string) {\n\t\t\tconst oAggregationElement = oAggregations[sAggregationName];\n\t\t\tif (oNode !== null && oNode !== undefined && oAggregationElement) {\n\t\t\t\t// slots can have :: as keys which is not a valid aggregation name therefore replacing them\n\t\t\t\tconst oElementChild = oAggregationElement.firstElementChild;\n\t\t\t\tif (sAggregationName !== \"customData\" && sAggregationName !== \"dependents\") {\n\t\t\t\t\tconst sSlotName =\n\t\t\t\t\t\t(oMetadataAggregations[sAggregationName] !== undefined && oMetadataAggregations[sAggregationName].slot) ||\n\t\t\t\t\t\tsAggregationName;\n\t\t\t\t\tconst oTargetElement = oNode.querySelector(`slot[name='${sSlotName}']`);\n\t\t\t\t\tif (oTargetElement !== null) {\n\t\t\t\t\t\tconst oNewChild = prepareAggregationElement(oNode, sAggregationName, oElementChild);\n\t\t\t\t\t\toTargetElement.replaceWith(...(oNewChild.children as unknown as Node[])); // Somehow TS doesn't like this but the documentation says is should work\n\t\t\t\t\t}\n\t\t\t\t} else if (processCustomData && oElementChild !== null) {\n\t\t\t\t\tconst oNewChild = prepareAggregationElement(oNode, sAggregationName, oElementChild);\n\t\t\t\t\toNode.appendChild(oNewChild);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n}\n\nfunction prepareAggregationElement(oNode: Element, sAggregationName: string, oElementChild: Element | null) {\n\tconst oNewChild = document.createElementNS(oNode.namespaceURI, sAggregationName.replace(/:/gi, \"_\"));\n\twhile (oElementChild) {\n\t\tconst oNextChild = oElementChild.nextElementSibling;\n\t\toNewChild.appendChild(oElementChild);\n\t\toElementChild = oNextChild;\n\t}\n\treturn oNewChild;\n}\n\nasync function processBuildingBlock(\n\tBuildingBlockClass: typeof BuildingBlockBase,\n\toNode: Element,\n\toVisitor: IVisitorCallback,\n\tisPublic = false\n) {\n\tconst oMetadata = transformMetadata(BuildingBlockClass.metadata);\n\n\tconst sFragmentName = oMetadata.fragment || `${oMetadata.namespace}.${oMetadata.xmlTag || oMetadata.name}`;\n\n\tconst mContexts: Record<string, Context> = {};\n\tconst oSettings = oVisitor.getSettings();\n\n\t// Add an empty converter context if there is none in order to have a place to store object values\n\toSettings.models.converterContext ??= new JSONModel();\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 to resolve the properties and the metadata contexts\n\tconst propertyValues = await processProperties(oMetadata, oNode, isPublic, oVisitor);\n\tconst initialKeys = Object.keys(propertyValues);\n\tconst mMissingContext = processContexts(oMetadata, oSettings, oNode, isPublic, oVisitor, mContexts, propertyValues);\n\n\ttry {\n\t\t// Aggregation and complex type support\n\t\tconst oAggregations = await processChildren(oNode, oVisitor, oMetadata, isPublic, propertyValues);\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\n\t\tObject.keys(propertyValues).forEach((propName) => {\n\t\t\tlet oData = propertyValues[propName] as unknown as Context;\n\t\t\t//check for additional processing function to validate / overwrite parameters\n\t\t\tconst originalDefinition = BuildingBlockClass?.metadata?.properties[propName];\n\t\t\tif (originalDefinition?.validate) {\n\t\t\t\toData = originalDefinition.validate(oData) || oData;\n\t\t\t}\n\t\t\tif (oData?.isA?.(SAP_UI_MODEL_CONTEXT) && !oData.getModel().isA(\"sap.ui.model.odata.v4.ODataMetaModel\")) {\n\t\t\t\tpropertyValues[propName] = oData.getObject();\n\t\t\t}\n\t\t});\n\t\tpropertyValues.isPublic = isPublic;\n\n\t\tconst oInstance = new BuildingBlockClass({ ...propertyValues, ...oAggregations }, oControlConfig, oSettings);\n\t\tprocessedPropertyValues = oInstance.getProperties();\n\t\tObject.keys(oMetadata.metadataContexts).forEach(function (sContextName: string) {\n\t\t\tif (processedPropertyValues.hasOwnProperty(sContextName)) {\n\t\t\t\tconst targetObject = processedPropertyValues[sContextName];\n\t\t\t\tif (typeof targetObject === \"object\" && !isContext(targetObject)) {\n\t\t\t\t\tconst attributeValue = storeObjectValue(targetObject);\n\t\t\t\t\toSettings.models.converterContext.setProperty(attributeValue, targetObject);\n\t\t\t\t\tconst newContext = oSettings.models.converterContext.createBindingContext(attributeValue)!;\n\t\t\t\t\tunstoreObjectValue(attributeValue);\n\t\t\t\t\tmContexts[sContextName] = newContext;\n\t\t\t\t} else if (!mContexts.hasOwnProperty(sContextName) && targetObject !== undefined) {\n\t\t\t\t\tmContexts[sContextName] = targetObject as Context;\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\n\t\tconst oAttributesModel: JSONModel = new AttributeModel(oNode, processedPropertyValues, BuildingBlockClass);\n\t\tmContexts[\"this\"] = oAttributesModel.createBindingContext(\"/\");\n\t\tlet oPreviousMacroInfo: MacroInfo | undefined;\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 as TraceMetadataContext)?.macroInfo) {\n\t\t\t\toPreviousMacroInfo = oSettings[\"_macroInfo\"];\n\t\t\t\toSettings[\"_macroInfo\"] = (oTraceInfo as TraceMetadataContext).macroInfo;\n\t\t\t}\n\t\t}\n\t\tvalidateMacroSignature(sFragmentName, oMetadata, mContexts, oNode);\n\n\t\tconst oContextVisitor = oVisitor.with(mContexts, oMetadata.isOpen !== undefined ? !oMetadata.isOpen : true);\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 (oMetadata.fragment) {\n\t\t\t\toPromise = oContextVisitor.insertFragment(sFragmentName, oNode);\n\t\t\t} else {\n\t\t\t\tconst templateString = await oInstance.getTemplate!(oNode);\n\n\t\t\t\tif (BuildingBlockClass.isRuntime) {\n\t\t\t\t\t// For runtime building blocks, we need to attach all objects to the converterContext directly, as the actual rendering takes place at runtime\n\t\t\t\t\tfor (const storeKey in temporaryObjectStore) {\n\t\t\t\t\t\tconst data = unstoreObjectValue(storeKey);\n\t\t\t\t\t\toSettings.models.converterContext.setProperty(storeKey, data);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tlet hasError = \"\";\n\t\t\t\tif (templateString) {\n\t\t\t\t\tlet hasParseError = false;\n\t\t\t\t\tlet parsedTemplate = parseXMLString(templateString, true);\n\t\t\t\t\t// For safety purpose we try to detect trailing text in between XML Tags\n\t\t\t\t\tfor (const element of parsedTemplate) {\n\t\t\t\t\t\tconst iter = document.createNodeIterator(element, NodeFilter.SHOW_TEXT);\n\t\t\t\t\t\tlet textnode = iter.nextNode();\n\t\t\t\t\t\tif (element.localName === \"parsererror\") {\n\t\t\t\t\t\t\thasParseError = true;\n\t\t\t\t\t\t}\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 (hasParseError) {\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\n\t\t\t\t\t\t// 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 ${oMetadata.xmlTag || oMetadata.name}`);\n\t\t\t\t\t\tparsedTemplate = await processXmlInTrace(async () => {\n\t\t\t\t\t\t\tconst initialTemplate = await oInstance.getTemplate?.(oNode);\n\t\t\t\t\t\t\treturn parseXMLString(initialTemplate ?? \"\", true);\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 ${oMetadata.xmlTag || oMetadata.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 ${oMetadata.xmlTag || oMetadata.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\tparsedTemplate.map((template) => template.outerHTML).join(\"\\n\")\n\t\t\t\t\t\t);\n\t\t\t\t\t\tparsedTemplate = parseXMLString(oErrorText, true);\n\t\t\t\t\t}\n\t\t\t\t\toNode.replaceWith(...parsedTemplate);\n\t\t\t\t\toNode = oParent.children[iChildIndex];\n\t\t\t\t\tprocessSlots(oAggregations, oMetadata.aggregations, oNode, false);\n\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}\n\n\t\t\tawait oPromise;\n\t\t\tconst oMacroElement = oParent.children[iChildIndex];\n\t\t\tprocessSlots(oAggregations, oMetadata.aggregations, oMacroElement, true);\n\t\t\tif (oMacroElement !== undefined) {\n\t\t\t\tconst oRemainingSlots = oMacroElement.querySelectorAll(\"slot\");\n\t\t\t\toRemainingSlots.forEach(function (oSlotElement) {\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: unknown) {\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 Record<string, unknown>,\n\t\t\tresolvedProperties: {} as Record<string, unknown>,\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 (isContext(propertyValue)) {\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 (isContext(propertyValue)) {\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\tLog.error(e as string);\n\t\tconst oError = createErrorXML(\n\t\t\t[`Error while processing building block ${oMetadata.name}`],\n\t\t\toNode.outerHTML,\n\t\t\ttraceDetails,\n\t\t\t(e as Error).stack\n\t\t);\n\t\tconst oTemplate = parseXMLString(oError, true);\n\t\toNode.replaceWith(...oTemplate);\n\t}\n}\nfunction addSingleContext(\n\tmContexts: Record<string, Context | undefined>,\n\toVisitor: IVisitorCallback,\n\toCtx: {\n\t\tname?: string;\n\t\tpath: string;\n\t\tmodel?: string;\n\t}\n) {\n\tconst sKey = (oCtx.name || oCtx.model || undefined) as string;\n\tif (mContexts[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 (oCtx.model === \"converterContext\" && oCtx.path.length > 0) {\n\t\t\tmContexts[sKey] = mSetting.models[oCtx.model].getContext(oCtx.path /*, mSetting.bindingContexts[oCtx.model]*/); // add the context to the visitor\n\t\t} else if (!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\t} catch (ex) {\n\t\t// ignore the context as this can only be the case if the model is not ready,\n\t\t// i.e. not a preprocessing model but maybe a model for providing afterwards\n\t}\n}\n\n/**\n * Register a building block definition to be used inside the xml template processor.\n *\n * @param BuildingBlockClass The building block definition\n */\nexport function registerBuildingBlock(BuildingBlockClass: typeof BuildingBlockBase): void {\n\tXMLPreprocessor.plugIn(\n\t\tasync (oNode: Element, oVisitor: IVisitorCallback) => processBuildingBlock(BuildingBlockClass, oNode, oVisitor),\n\t\tBuildingBlockClass.metadata.namespace,\n\t\tBuildingBlockClass.metadata.xmlTag || BuildingBlockClass.metadata.name\n\t);\n\tif (BuildingBlockClass.metadata.publicNamespace) {\n\t\tXMLPreprocessor.plugIn(\n\t\t\tasync (oNode: Element, oVisitor: IVisitorCallback) => processBuildingBlock(BuildingBlockClass, oNode, oVisitor, true),\n\t\t\tBuildingBlockClass.metadata.publicNamespace,\n\t\t\tBuildingBlockClass.metadata.xmlTag || BuildingBlockClass.metadata.name\n\t\t);\n\t}\n}\n\n/**\n * UnRegister a building block definition so that it is no longer used inside the xml template processor.\n *\n * @param BuildingBlockClass The building block definition\n */\nexport function unregisterBuildingBlock(BuildingBlockClass: typeof BuildingBlockBase): void {\n\tif (BuildingBlockClass.metadata.namespace !== undefined) {\n\t\tXMLPreprocessor.plugIn(\n\t\t\tnull,\n\t\t\tBuildingBlockClass.metadata.namespace,\n\t\t\tBuildingBlockClass.metadata.xmlTag || BuildingBlockClass.metadata.name\n\t\t);\n\t}\n\tif (BuildingBlockClass.metadata.publicNamespace !== undefined) {\n\t\tXMLPreprocessor.plugIn(\n\t\t\tnull,\n\t\t\tBuildingBlockClass.metadata.publicNamespace,\n\t\t\tBuildingBlockClass.metadata.xmlTag || BuildingBlockClass.metadata.name\n\t\t);\n\t}\n}\n\nfunction createErrorXML(errorMessages: string[], xmlFragment: string, additionalData?: object, stack?: string): string {\n\tconst errorLabels = errorMessages.map((errorMessage) => xml`<m:Label text=\"${escapeXMLAttributeValue(errorMessage)}\"/>`);\n\tlet errorStack = \"\";\n\tif (stack) {\n\t\tconst stackFormatted = btoa(`<pre>${stack}</pre>`);\n\t\terrorStack = xml`<m:FormattedText htmlText=\"${`{= BBF.base64Decode('${stackFormatted}') }`}\" />`;\n\t}\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=\"${`{= BBF.base64Decode('${btoa(JSON.stringify(additionalData, null, 4))}') }`}\" height=\"300px\" />\n\t\t\t\t\t</m:VBox>`;\n\t}\n\treturn xml`<controls:FormElementWrapper xmlns:controls=\"sap.fe.core.controls\">\n\t\t\t\t\t<m:VBox xmlns:m=\"sap.m\" xmlns:code=\"sap.ui.codeeditor\" core:require=\"{BBF:'sap/fe/core/buildingBlocks/BuildingBlockFormatter'}\">\n\t\t\t\t\t${errorLabels}\n\t\t\t\t\t${errorStack}\n\t\t\t\t\t\t<grid:CSSGrid gridTemplateRows=\"fr\" gridTemplateColumns=\"repeat(2,1fr)\" gridGap=\"1rem\" xmlns:grid=\"sap.ui.layout.cssgrid\" >\n\t\t\t\t\t\t\t<m:VBox>\n\t\t\t\t\t\t\t\t<m:Label text=\"How the building block was called\"/>\n\t\t\t\t\t\t\t\t<code:CodeEditor type=\"xml\" value=\"${`{= BBF.base64Decode('${btoa(xmlFragment.replaceAll(\"&gt;\", \">\"))}') }`}\" height=\"300px\" />\n\t\t\t\t\t\t\t</m:VBox>\n\t\t\t\t\t\t\t${additionalText}\n\t\t\t\t\t\t</grid:CSSGrid>\n\t\t\t\t\t</m:VBox>\n\t\t\t\t</controls:FormElementWrapper>`;\n}\n\nconst temporaryObjectStore: Record<string, unknown> = {};\n\n/**\n * Stores an object value in a temporary storage and returns an ID used to retrieve this value at a later point in time.\n *\n * Required as there is functionality like the xml` function, which might take objects as parameters but needs to return a serialized string.\n *\n * @param value Value to store\n * @returns ID to retrieve this value\n */\nfunction storeObjectValue(value: unknown) {\n\tconst propertyUID = `/uid--${uid()}`;\n\ttemporaryObjectStore[propertyUID] = value;\n\treturn propertyUID;\n}\n\n/**\n * Unstores an object from a temporary store by removing it and returning its object value.\n *\n * @param propertyUID ID to retrieve this value\n * @returns Object value\n */\nfunction unstoreObjectValue(propertyUID: string) {\n\tconst value = temporaryObjectStore[propertyUID];\n\tdelete temporaryObjectStore[propertyUID];\n\treturn value;\n}\n\nlet processNextXmlInTrace = false;\n/**\n * Makes sure that all xml` calls inside the given method are processed in trace mode.\n *\n * @param method The method to execute\n * @returns The return value of the given method\n */\nconst processXmlInTrace = function (method: Function) {\n\tprocessNextXmlInTrace = true;\n\tlet returnValue;\n\ttry {\n\t\treturnValue = method();\n\t} finally {\n\t\tprocessNextXmlInTrace = false;\n\t}\n\treturn returnValue;\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 default namespaces should be added\n * @returns The XML document.\n */\nexport function 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:macros=\"sap.fe.macros\"\n\t\t\t\t\t\txmlns:core=\"sap.ui.core\"\n\t\t\t\t\t\txmlns:mdc=\"sap.ui.mdc\"\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\tconst children = output?.parentElement ? output?.parentElement.children : [output as Element];\n\treturn Array.from(children);\n}\n\n/**\n * Escape an XML attribute value.\n *\n * @param value The attribute value to escape.\n * @returns The escaped string.\n */\nexport function escapeXMLAttributeValue(value?: string): string | undefined {\n\treturn value?.replace(/&/g, \"&amp;\").replace(/</g, \"&lt;\").replace(/\"/g, \"&quot;\").replace(/'/g, \"&apos;\");\n}\n\nfunction renderInTraceMode(outStr: string) {\n\tconst xmlResult = parseXMLString(outStr, true);\n\tif (xmlResult?.length > 0 && xmlResult[0]?.localName === \"parsererror\") {\n\t\tconst errorMessage = (xmlResult[0] as HTMLElement).innerText || (xmlResult[0] as HTMLElement).innerHTML;\n\t\treturn createErrorXML([errorMessage.split(\"\\n\")[0]], outStr);\n\t} else {\n\t\treturn outStr;\n\t}\n}\n\nexport type XMLProcessorTypeValue =\n\t| string\n\t| boolean\n\t| number\n\t| undefined\n\t| null\n\t| object\n\t| Record<string, unknown>\n\t| BindingToolkitExpression<string | boolean | number>\n\t| Array<string>\n\t| Array<Function>\n\t| Function\n\t| Context;\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: XMLProcessorTypeValue[]) => {\n\tlet outStr = \"\";\n\tlet i;\n\tfor (i = 0; i < values.length; i++) {\n\t\toutStr += strings[i];\n\n\t\t// Handle the different case of object, if it's an array we join them, if it's a binding expression then we compile it.\n\t\tconst value = values[i];\n\n\t\tif (Array.isArray(value) && value.length > 0 && typeof value[0] === \"string\") {\n\t\t\toutStr += value.flat(5).join(\"\\n\").trim();\n\t\t} else if (isFunctionArray(value)) {\n\t\t\toutStr += value.map((valuefn) => valuefn()).join(\"\\n\");\n\t\t} else if (isBindingToolkitExpression(value)) {\n\t\t\tconst compiledExpression = compileExpression(value);\n\t\t\toutStr += escapeXMLAttributeValue(compiledExpression);\n\t\t} else if (typeof value === \"undefined\") {\n\t\t\toutStr += \"{this>undefinedValue}\";\n\t\t} else if (typeof value === \"function\") {\n\t\t\toutStr += value();\n\t\t} else if (typeof value === \"object\" && value !== null) {\n\t\t\tif (isContext(value)) {\n\t\t\t\toutStr += value.getPath();\n\t\t\t} else {\n\t\t\t\tconst propertyUId = storeObjectValue(value);\n\t\t\t\toutStr += `${propertyUId}`;\n\t\t\t}\n\t\t} else if (value && typeof value === \"string\" && !value.startsWith(\"<\") && !value.startsWith(\"&lt;\")) {\n\t\t\toutStr += escapeXMLAttributeValue(value);\n\t\t} else {\n\t\t\toutStr += value;\n\t\t}\n\t}\n\toutStr += strings[i];\n\toutStr = outStr.trim();\n\tif (processNextXmlInTrace) {\n\t\treturn renderInTraceMode(outStr);\n\t}\n\treturn outStr;\n};\n"],"mappings":"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"}