@sapui5/sap.fe.core 1.100.0 → 1.102.0

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

@@ -0,0 +1,837 @@
+import Log from "sap/base/Log";
+import uid from "sap/base/util/uid";
+import AttributeModel from "sap/fe/core/buildingBlocks/AttributeModel";
+import {
+	BuildingBlockAggregationDefinition,
+	BuildingBlockBase,
+	BuildingBlockDefinition,
+	BuildingBlockDefinitionV1,
+	BuildingBlockMetadata,
+	BuildingBlockMetadataContextDefinition,
+	BuildingBlockPropertyDefinition
+} from "sap/fe/core/buildingBlocks/BuildingBlock";
+import { compileBinding } from "sap/fe/core/helpers/BindingExpression";
+import ResourceModel from "sap/fe/macros/ResourceModel";
+import BindingParser from "sap/ui/base/BindingParser";
+import XMLPreprocessor from "sap/ui/core/util/XMLPreprocessor";
+import Context from "sap/ui/model/Context";
+import JSONModel from "sap/ui/model/json/JSONModel";
+import TraceInfo from "./TraceInfo";
+
+const LOGGER_SCOPE = "sap.fe.core.buildingBlocks.BuildingBlockRuntime";
+const DOMParserInstance = new DOMParser();
+let isTraceMode = false;
+
+type ResolvedBuildingBlockMetadata = {
+	properties: Record<string, BuildingBlockPropertyDefinition>;
+	aggregations: Record<string, BuildingBlockAggregationDefinition>;
+	metadataContexts: Record<string, BuildingBlockMetadataContextDefinition>;
+	isOpen: boolean;
+};
+
+type ICallback = {
+	getSettings(): any;
+	/**
+	 * Visits the given node and either processes a template instruction, calls
+	 * a visitor, or simply calls both {@link
+	 * sap.ui.core.util.XMLPreprocessor.ICallback.visitAttributes visitAttributes}
+	 * and {@link sap.ui.core.util.XMLPreprocessor.ICallback.visitChildNodes
+	 * visitChildNodes}.
+	 *
+	 * @param {Node} oNode
+	 *   The XML DOM node
+	 * @returns {sap.ui.base.SyncPromise}
+	 *   A thenable which resolves with <code>undefined</code> as soon as visiting
+	 *   is done, or is rejected with a corresponding error if visiting fails
+	 **/
+	visitNode(oNode: Node): Promise<void>;
+
+	/**
+	 * Inserts the fragment with the given name in place of the given element. Loads the
+	 * fragment, takes care of caching (for the current pre-processor run) and visits the
+	 * fragment's content once it has been imported into the element's owner document and
+	 * put into place. Loading of fragments is asynchronous if the template view is
+	 * asynchronous.
+	 *
+	 * @param {string} sFragmentName
+	 *   the fragment's resolved name
+	 * @param {Element} oElement
+	 *   the XML DOM element, e.g. <sap.ui.core:Fragment> or <core:ExtensionPoint>
+	 * @param {sap.ui.core.util._with} oWithControl
+	 *   the parent's "with" control
+	 * @returns {sap.ui.base.SyncPromise}
+	 * A sync promise which resolves with <code>undefined</code> as soon as the fragment
+	 *   has been inserted, or is rejected with a corresponding error if loading or visiting
+	 *   fails.
+	 */
+	insertFragment(sFragment: string, oElement: Element, oWith?: any): Promise<void>;
+	visitAttribute(oNode: Element, oAttribute: Attr): Promise<void>;
+	visitChildNodes(oNode: Node): Promise<void>;
+	/**
+	 * Interprets the given XML DOM attribute value as a binding and returns the
+	 * resulting value.
+	 * @param {string} sValue
+	 *   An XML DOM attribute value
+	 * @param {Element} [oElement]
+	 *   The XML DOM element the attribute value belongs to (needed only for
+	 *   warnings which are logged to the console)
+	 * @returns {sap.ui.base.SyncPromise|null}
+	 *   A thenable which resolves with the resulting value, or is rejected with a
+	 *   corresponding error (for example, an error thrown by a formatter) or
+	 *   <code>null</code> in case the binding is not ready (because it refers to a
+	 *   model which is not available) (since 1.57.0)
+	 */
+	getResult(sValue: string, element?: Element): Promise<any> | null;
+	getContext(sPath: string): Context;
+	/**
+	 * Returns a callback interface instance for the given map of variables which
+	 * override currently known variables of the same name in <code>this</code>
+	 * parent interface or replace them altogether. Each variable name becomes a
+	 * named model with a corresponding object binding and can be used inside the
+	 * XML template in the usual way, that is, with a binding expression like
+	 * <code>"{var>some/relative/path}"</code> (see example).
+	 *
+	 * @param {object} [mVariables={}]
+	 *   Map from variable name (string) to value ({@link sap.ui.model.Context})
+	 * @param {boolean} [bReplace]
+	 *   Whether only the given variables are known in the new callback interface
+	 *   instance, no inherited ones
+	 * @returns {sap.ui.core.util.XMLPreprocessor.ICallback}
+	 *   A callback interface instance
+	 * @param mVariables
+	 * @param bReplace
+	 */
+	"with"(mVariables?: any, bReplace?: boolean): ICallback;
+};
+
+/**
+ * Typeguard for checking if a building block use API 1.
+ *
+ * @param buildingBlockDefinition
+ * @returns `true` if the building block is using API 1.
+ */
+function isV1MacroDef(buildingBlockDefinition: BuildingBlockDefinition): buildingBlockDefinition is BuildingBlockDefinitionV1 {
+	return buildingBlockDefinition.apiVersion === undefined || buildingBlockDefinition.apiVersion === 1;
+}
+function validateMacroMetadataContext(
+	sName: string,
+	mContexts: any,
+	oContextSettings: BuildingBlockMetadataContextDefinition,
+	sKey: string
+) {
+	const oContext = mContexts[sKey];
+	const oContextObject = oContext?.getObject();
+
+	if (oContextSettings.required && (!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") && oContextSettings.$kind) {
+			// 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") && 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()}`
+				);
+			}
+		}
+	}
+}
+export function validateMacroSignature(sName: any, oMetadata: any, mContexts: any, oNode: any) {
+	const aMetadataContextKeys = (oMetadata.metadataContexts && Object.keys(oMetadata.metadataContexts)) || [],
+		aProperties = (oMetadata.properties && Object.keys(oMetadata.properties)) || [],
+		oAttributeNames: any = {};
+
+	// collect all attributes to find unchecked properties
+	Object.keys(oNode.attributes).forEach(function (iKey: string) {
+		const sKey = oNode.attributes[iKey].name;
+		oAttributeNames[sKey] = true;
+	});
+
+	//Check metadataContexts
+	aMetadataContextKeys.forEach(function (sKey: any) {
+		const oContextSettings = oMetadata.metadataContexts[sKey];
+
+		validateMacroMetadataContext(sName, mContexts, oContextSettings, sKey);
+		delete oAttributeNames[sKey];
+	});
+	//Check properties
+	aProperties.forEach(function (sKey: any) {
+		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: string) {
+		// no check for properties which start with underscore "_" or contain a colon ":" (different namespace), e.g. xmlns:trace, trace:macroID, unittest:id
+		if (sKey.indexOf(":") < 0 && !sKey.startsWith("xmlns")) {
+			Log.warning(`Unchecked parameter: ${sName}: ${sKey}`, undefined, LOGGER_SCOPE);
+		}
+	});
+}
+
+/**
+ * Ensures that the metadata for the building block are properly defined.
+ *
+ * @param buildingBlockMetadata The metadata received from the input
+ * @param isOpen Whether the building block is open or not
+ * @returns A set of completed metadata for further processing
+ */
+function prepareMetadata(buildingBlockMetadata?: BuildingBlockMetadata, isOpen = false): ResolvedBuildingBlockMetadata {
+	if (buildingBlockMetadata) {
+		const oProperties: any = {};
+		const oAggregations: any = {
+			"dependents": {
+				type: "sap.ui.core.Element"
+			},
+			"customData": {
+				type: "sap.ui.core.Element"
+			}
+		};
+		const oMetadataContexts: Record<string, BuildingBlockPropertyDefinition> = {};
+
+		Object.keys(buildingBlockMetadata.properties).forEach(function (sPropertyName: string) {
+			if (buildingBlockMetadata.properties[sPropertyName].type !== "sap.ui.model.Context") {
+				oProperties[sPropertyName] = buildingBlockMetadata.properties[sPropertyName];
+			} else {
+				oMetadataContexts[sPropertyName] = buildingBlockMetadata.properties[sPropertyName];
+			}
+		});
+		// Merge events into properties as they are handled identically
+		if (buildingBlockMetadata.events) {
+			Object.keys(buildingBlockMetadata.events).forEach(function (sEventName: string) {
+				oProperties[sEventName] = buildingBlockMetadata.events[sEventName];
+			});
+		}
+		if (buildingBlockMetadata.aggregations) {
+			Object.keys(buildingBlockMetadata.aggregations).forEach(function (sPropertyName: string) {
+				oAggregations[sPropertyName] = buildingBlockMetadata.aggregations[sPropertyName];
+			});
+		}
+		return {
+			properties: oProperties,
+			aggregations: oAggregations,
+			metadataContexts: oMetadataContexts,
+			isOpen: isOpen
+		};
+	} else {
+		return {
+			metadataContexts: {},
+			aggregations: {
+				"dependents": {
+					type: "sap.ui.core.Element"
+				},
+				"customData": {
+					type: "sap.ui.core.Element"
+				}
+			},
+			properties: {},
+			isOpen: isOpen
+		};
+	}
+}
+
+function _getMetadataContext(
+	oSettings: any,
+	oNode: Element,
+	sAttributeName: string,
+	oVisitor: ICallback,
+	bDoNotResolve: boolean,
+	isOpen: boolean
+) {
+	let oMetadataContext;
+	if (!bDoNotResolve && oNode.hasAttribute(sAttributeName)) {
+		const sAttributeValue = oNode.getAttribute(sAttributeName) as string;
+		let sMetaPath;
+		// oVisitor.getResult(sAttributeValue, oNode);
+		oMetadataContext = BindingParser.complexParser(sAttributeValue);
+		if (!oMetadataContext) {
+			if (sAttributeValue.startsWith("uid--")) {
+				const oData = myStore[sAttributeValue];
+				const sContextPath = "/" + sAttributeValue;
+				oSettings.models.converterContext.setProperty(sContextPath, oData);
+				oMetadataContext = {
+					model: "converterContext",
+					path: sContextPath
+				};
+			} else if ((sAttributeName === "metaPath" && oSettings.currentContextPath) || sAttributeName === "contextPath") {
+				if (sAttributeValue && sAttributeValue.startsWith("/")) {
+					// absolute path - we just use this one
+					sMetaPath = sAttributeValue;
+				} else {
+					let sContextPath = oSettings.currentContextPath.getPath();
+					if (!sContextPath.endsWith("/")) {
+						sContextPath += "/";
+					}
+					sMetaPath = sContextPath + sAttributeValue;
+				}
+				oMetadataContext = {
+					model: "metaModel",
+					path: sMetaPath
+				};
+			} else {
+				oMetadataContext = {
+					model: "metaModel",
+					path: oSettings.bindingContexts.entitySet
+						? oSettings.bindingContexts.entitySet.getPath(sAttributeValue)
+						: sAttributeValue
+				};
+			}
+		}
+	} else if (oSettings.bindingContexts.hasOwnProperty(sAttributeName)) {
+		oMetadataContext = {
+			model: sAttributeName,
+			path: ""
+		};
+	} else if (isOpen) {
+		try {
+			if (oVisitor.getContext(`${sAttributeName}>`)) {
+				oMetadataContext = {
+					model: sAttributeName,
+					path: ""
+				};
+			}
+		} catch (e) {
+			oMetadataContext = undefined;
+		}
+	}
+	return oMetadataContext;
+}
+
+async function processProperties(
+	oMetadata: ResolvedBuildingBlockMetadata,
+	oSettings: any,
+	oNode: Element,
+	isPublic: boolean,
+	oVisitor: ICallback,
+	mContexts: any,
+	oMetadataContexts: any
+) {
+	const mMissingContext: any = {};
+	const oDefinitionProperties = oMetadata.properties;
+	const oDefinitionContexts = oMetadata.metadataContexts;
+	oSettings.currentContextPath = oSettings.bindingContexts.contextPath;
+
+	// Retrieve properties values
+	const aDefinitionPropertiesKeys = Object.keys(oDefinitionProperties);
+	let aDefinitionContextsKeys = Object.keys(oDefinitionContexts);
+	const propertyValues: Record<string, any> = {};
+	for (let j = 0; j < aDefinitionPropertiesKeys.length; j++) {
+		const sKeyValue = aDefinitionPropertiesKeys[j];
+		if (oDefinitionProperties[sKeyValue].type === "object") {
+			propertyValues[sKeyValue] = {}; // To avoid vales being reused accross macros
+		} else {
+			propertyValues[sKeyValue] = oDefinitionProperties[sKeyValue].defaultValue;
+		}
+		if (oNode.hasAttribute(sKeyValue) && isPublic && !oDefinitionProperties[sKeyValue].isPublic) {
+			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) as Attr);
+			const vValue = oNode.getAttribute(sKeyValue);
+			if (vValue !== undefined) {
+				propertyValues[sKeyValue] = vValue;
+			}
+		}
+	}
+	// Sort keys to be sure contextPath is before metaPath ( yes I'm desperate )
+	aDefinitionContextsKeys = aDefinitionContextsKeys.sort(function (a: string, b: string) {
+		return a > b ? 1 : -1;
+	});
+	for (const sAttributeName of aDefinitionContextsKeys) {
+		const bDoNotResolve = isPublic && !oDefinitionContexts[sAttributeName].isPublic && oNode.hasAttribute(sAttributeName);
+		const oMetadataContext = _getMetadataContext(oSettings, oNode, sAttributeName, oVisitor, bDoNotResolve, oMetadata.isOpen);
+		if (oMetadataContext) {
+			oMetadataContext.name = sAttributeName;
+			addSingleContext(mContexts, oVisitor, oMetadataContext, oMetadataContexts);
+			if (
+				(sAttributeName === "entitySet" && !oSettings.bindingContexts.hasOwnProperty(sAttributeName)) ||
+				(sAttributeName === "contextPath" && !oSettings.bindingContexts.hasOwnProperty(sAttributeName))
+			) {
+				oSettings.bindingContexts[sAttributeName] = mContexts[sAttributeName];
+			}
+			if (sAttributeName === "contextPath") {
+				oSettings.currentContextPath = mContexts[sAttributeName];
+			}
+			propertyValues[sAttributeName] = mContexts[sAttributeName];
+		} else {
+			mMissingContext[sAttributeName] = true;
+		}
+	}
+	return { mMissingContext, propertyValues: propertyValues };
+}
+
+async function processChildren(
+	oNode: Element,
+	oVisitor: ICallback,
+	oMetadata: ResolvedBuildingBlockMetadata,
+	isPublic: boolean,
+	propertyValues: Record<string, any>
+) {
+	const oAggregations: any = {};
+	if (oNode.firstElementChild !== null) {
+		// If there are aggregation we need to visit the childNodes first and foremost
+		await oVisitor.visitChildNodes(oNode);
+		let oFirstElementChild: Element | null = oNode.firstElementChild;
+		while (oFirstElementChild !== null) {
+			const sChildName = oFirstElementChild.localName;
+			if (
+				Object.keys(oMetadata.aggregations).indexOf(sChildName) !== -1 &&
+				(!isPublic || oMetadata.aggregations[sChildName].isPublic)
+			) {
+				oAggregations[oFirstElementChild.localName] = oFirstElementChild;
+			} else if (Object.keys(oMetadata.properties).indexOf(sChildName) !== -1) {
+				// Object Type properties
+				propertyValues[sChildName] = {};
+				for (const attributeIndex of Object.keys(oFirstElementChild.attributes)) {
+					propertyValues[sChildName][oFirstElementChild.attributes[attributeIndex as any].localName] =
+						oFirstElementChild.attributes[attributeIndex as any].value;
+				}
+			}
+
+			oFirstElementChild = oFirstElementChild.nextElementSibling;
+		}
+	}
+	return oAggregations;
+}
+
+async function processBuildingBlock(
+	buildingBLockDefinition: BuildingBlockDefinition,
+	oNode: Element,
+	oVisitor: ICallback,
+	isPublic = false
+) {
+	const sFragmentName = buildingBLockDefinition.fragment || `${buildingBLockDefinition.namespace}.${buildingBLockDefinition.name}`;
+
+	const sName = "this";
+
+	const mContexts: any = {};
+	const oMetadataContexts: any = {};
+	const oSettings = oVisitor.getSettings();
+	// TODO 0001 Move this elsewhere this is weird :)
+	if (oSettings.models["sap.fe.i18n"]) {
+		oSettings.models["sap.fe.i18n"]
+			.getResourceBundle()
+			.then(function (oResourceBundle: any) {
+				ResourceModel.setApplicationI18nBundle(oResourceBundle);
+			})
+			.catch(function (error: any) {
+				Log.error(error);
+			});
+	}
+	const oMetadata = prepareMetadata(buildingBLockDefinition.metadata, buildingBLockDefinition.isOpen);
+
+	//Inject storage for macros
+	if (!oSettings[sFragmentName]) {
+		oSettings[sFragmentName] = {};
+	}
+
+	// First of all we need to visit the attributes
+	const { mMissingContext, propertyValues } = await processProperties(
+		oMetadata,
+		oSettings,
+		oNode,
+		isPublic,
+		oVisitor,
+		mContexts,
+		oMetadataContexts
+	);
+	const initialKeys = Object.keys(propertyValues);
+	try {
+		// Aggregation and complex type support
+		const oAggregations = await processChildren(oNode, oVisitor, oMetadata, isPublic, propertyValues);
+		let oInstance: any;
+		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;
+		if (isV1MacroDef(buildingBLockDefinition) && buildingBLockDefinition.create) {
+			processedPropertyValues = buildingBLockDefinition.create.call(
+				buildingBLockDefinition,
+				propertyValues,
+				oControlConfig,
+				oSettings,
+				oAggregations,
+				isPublic
+			);
+			Object.keys(oMetadata.metadataContexts).forEach(function (sMetadataName: string) {
+				if (oMetadata.metadataContexts[sMetadataName].computed) {
+					mContexts[sMetadataName] = processedPropertyValues[sMetadataName];
+				}
+			});
+			Object.keys(mMissingContext).forEach(function (sContextName: string) {
+				if (processedPropertyValues.hasOwnProperty(sContextName)) {
+					mContexts[sContextName] = processedPropertyValues[sContextName];
+				}
+			});
+		} else if (buildingBLockDefinition.apiVersion === 2) {
+			Object.keys(propertyValues).forEach((propName) => {
+				const oData = propertyValues[propName];
+				if (
+					oData &&
+					oData.isA &&
+					oData.isA("sap.ui.model.Context") &&
+					!oData.getModel().isA("sap.ui.model.odata.v4.ODataMetaModel")
+				) {
+					propertyValues[propName] = oData.getObject();
+				}
+			});
+			const BuildingBlockClass = buildingBLockDefinition as typeof BuildingBlockBase;
+			oInstance = new BuildingBlockClass(propertyValues /*, oControlConfig, oSettings, oAggregations, isPublic*/);
+		}
+		const oAttributesModel: JSONModel = new AttributeModel(oNode, processedPropertyValues, buildingBLockDefinition);
+		mContexts[sName] = oAttributesModel.createBindingContext("/");
+
+		let oPreviousMacroInfo: any;
+
+		// Keep track
+		if (TraceInfo.isTraceInfoActive()) {
+			const oTraceInfo = TraceInfo.traceMacroCalls(sFragmentName, oMetadata, mContexts, oNode, oVisitor);
+			if (oTraceInfo) {
+				oPreviousMacroInfo = oSettings["_macroInfo"];
+				oSettings["_macroInfo"] = oTraceInfo.macroInfo;
+			}
+		}
+		validateMacroSignature(sFragmentName, oMetadata, mContexts, oNode);
+
+		const oContextVisitor = oVisitor.with(
+			mContexts,
+			buildingBLockDefinition.isOpen !== undefined ? !buildingBLockDefinition.isOpen : true
+		);
+		const oParent = oNode.parentNode;
+
+		let iChildIndex: number;
+		let oPromise;
+		if (oParent) {
+			iChildIndex = Array.from(oParent.children).indexOf(oNode);
+
+			if (
+				(isV1MacroDef(buildingBLockDefinition) && buildingBLockDefinition.getTemplate) ||
+				buildingBLockDefinition.apiVersion === 2
+			) {
+				let oTemplate;
+				let addDefaultNamespace = false;
+				if (buildingBLockDefinition.apiVersion === 2) {
+					oTemplate = oInstance.getTemplate();
+					addDefaultNamespace = true;
+				} else if (buildingBLockDefinition.getTemplate) {
+					oTemplate = buildingBLockDefinition.getTemplate(processedPropertyValues);
+				}
+
+				let hasError = "";
+				if (oTemplate) {
+					if (!oTemplate.firstElementChild) {
+						oTemplate = parseXMLString(oTemplate, addDefaultNamespace);
+						// For safety purpose we try to detect trailing text in between XML Tags
+						const iter = document.createNodeIterator(oTemplate, NodeFilter.SHOW_TEXT);
+						let textnode = iter.nextNode();
+						while (textnode) {
+							if (textnode.textContent && textnode.textContent.trim().length > 0) {
+								hasError = textnode.textContent;
+							}
+							textnode = iter.nextNode();
+						}
+					}
+
+					if (oTemplate.localName === "parsererror") {
+						// If there is a parseerror while processing the XML it means the XML itself is malformed, as such we rerun the template process
+						// Setting isTraceMode true will make it so that each xml` expression is checked for validity from XML perspective and if an error is found it's returned instead of the normal fragment
+						Log.error(`Error while processing building block ${buildingBLockDefinition.name}`);
+						try {
+							isTraceMode = true;
+							oTemplate = oInstance?.getTemplate
+								? oInstance.getTemplate()
+								: (buildingBLockDefinition as any).getTemplate(processedPropertyValues);
+							oTemplate = parseXMLString(oTemplate, true);
+						} finally {
+							isTraceMode = false;
+						}
+					} else if (hasError.length > 0) {
+						// If there is trailing text we create a standard error and display it.
+						Log.error(`Error while processing building block ${buildingBLockDefinition.name}`);
+						const oErrorText = createErrorXML(
+							[
+								`Error while processing building block ${buildingBLockDefinition.name}`,
+								`Trailing text was found in the XML: ${hasError}`
+							],
+							oTemplate.outerHTML
+						);
+						oTemplate = parseXMLString(oErrorText, true);
+					}
+					oNode.replaceWith(oTemplate);
+					oNode = oParent.children[iChildIndex];
+					oPromise = oContextVisitor.visitNode(oNode);
+				} else {
+					oNode.remove();
+					oPromise = Promise.resolve();
+				}
+			} else {
+				oPromise = oContextVisitor.insertFragment(sFragmentName, oNode);
+			}
+
+			await oPromise;
+			const oMacroElement = oParent.children[iChildIndex];
+
+			if (Object.keys(oAggregations).length > 0) {
+				Object.keys(oAggregations).forEach(function (sAggregationName: string) {
+					const oAggregationElement = oAggregations[sAggregationName];
+					if (oMacroElement !== null && oMacroElement !== undefined) {
+						const oNewChild = document.createElementNS(oMacroElement.namespaceURI, sAggregationName);
+						let oElementChild = oAggregationElement.firstElementChild;
+						while (oElementChild) {
+							const oNextChild = oElementChild.nextElementSibling;
+							oNewChild.appendChild(oElementChild);
+							oElementChild = oNextChild;
+						}
+						if (sAggregationName !== "customData" && sAggregationName !== "dependents") {
+							const sSlotName =
+								(oMetadata.aggregations[sAggregationName] && oMetadata.aggregations[sAggregationName].slot) ||
+								sAggregationName;
+							const oTargetElement = oMacroElement.querySelector("slot[name='" + sSlotName + "']") as Element;
+							if (oTargetElement) {
+								oTargetElement.replaceWith(...(oNewChild.children as any));
+							}
+						} else {
+							oMacroElement.appendChild(oNewChild);
+						}
+					}
+				});
+			}
+			if (oMacroElement) {
+				const oRemainingSlots = oMacroElement.querySelectorAll("slot");
+				oRemainingSlots.forEach(function (oSlotElement: any) {
+					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: {} as any,
+			resolvedProperties: {} as any,
+			missingContexts: mMissingContext
+		};
+		for (const propertyName of initialKeys) {
+			const propertyValue = propertyValues[propertyName];
+			if (propertyValue && propertyValue.isA && propertyValue.isA("sap.ui.model.Context")) {
+				traceDetails.initialProperties[propertyName] = {
+					path: propertyValue.getPath(),
+					value: propertyValue.getObject()
+				};
+			} else {
+				traceDetails.initialProperties[propertyName] = propertyValue;
+			}
+		}
+		for (const propertyName in propertyValues) {
+			const propertyValue = propertyValues[propertyName];
+			if (!initialKeys.includes(propertyName)) {
+				if (propertyValue && propertyValue.isA && propertyValue.isA("sap.ui.model.Context")) {
+					traceDetails.resolvedProperties[propertyName] = {
+						path: propertyValue.getPath(),
+						value: propertyValue.getObject()
+					};
+				} else {
+					traceDetails.resolvedProperties[propertyName] = propertyValue;
+				}
+			}
+		}
+		const errorAny = e as any;
+		Log.error(errorAny, errorAny);
+		const oError = createErrorXML(
+			[`Error while processing building block ${buildingBLockDefinition.name}`, errorAny.stack],
+			oNode.outerHTML,
+			traceDetails
+		);
+		const oTemplate = parseXMLString(oError, true);
+		oNode.replaceWith(oTemplate as any);
+	}
+}
+function addSingleContext(mContexts: any, oVisitor: any, oCtx: any, oMetadataContexts: any) {
+	const sKey = oCtx.name || oCtx.model || undefined;
+
+	if (oMetadataContexts[sKey]) {
+		return; // do not add twice
+	}
+	try {
+		let sContextPath = oCtx.path;
+		if (oCtx.model != null) {
+			sContextPath = oCtx.model + ">" + sContextPath;
+		}
+		const mSetting = oVisitor.getSettings();
+		if (!mSetting.bindingContexts[oCtx.model] && mSetting.models[oCtx.model]) {
+			mContexts[sKey] = mSetting.models[oCtx.model].getContext(oCtx.path); // add the context to the visitor
+		} else {
+			mContexts[sKey] = oVisitor.getContext(sContextPath); // add the context to the visitor
+		}
+
+		oMetadataContexts[sKey] = mContexts[sKey]; // make it available inside metadataContexts JSON object
+	} catch (ex) {
+		//console.error(ex);
+		// ignore the context as this can only be the case if the model is not ready, i.e. not a preprocessing model but maybe a model for
+		// providing afterwards
+		// TODO 0002 not yet implemented
+		//mContexts["_$error"].oModel.setProperty("/" + sKey, ex);
+	}
+}
+
+/**
+ * Register a building block definition to be used inside the xml template processor.
+ *
+ * @param buildingBlockDefinition The building block definition
+ */
+export function registerBuildingBlock(buildingBlockDefinition: BuildingBlockDefinition): void {
+	XMLPreprocessor.plugIn(
+		(oNode: Element, oVisitor: ICallback) => processBuildingBlock(buildingBlockDefinition, oNode, oVisitor),
+		buildingBlockDefinition.namespace,
+		buildingBlockDefinition.xmlTag || buildingBlockDefinition.name
+	);
+	if (buildingBlockDefinition.publicNamespace) {
+		XMLPreprocessor.plugIn(
+			(oNode: Element, oVisitor: ICallback) => processBuildingBlock(buildingBlockDefinition, oNode, oVisitor, true),
+			buildingBlockDefinition.publicNamespace,
+			buildingBlockDefinition.xmlTag || buildingBlockDefinition.name
+		);
+	}
+}
+
+function createErrorXML(errorMessages: string[], xmlFragment: string, additionalData?: object): string {
+	const errorLabels = errorMessages.map((errorMessage) => xml`<m:Label text="${escapeXML(errorMessage)}"/>`);
+	let additionalText = "";
+	if (additionalData) {
+		additionalText = xml`<m:VBox>
+						<m:Label text="Trace Info"/>
+						<code:CodeEditor type="json" value="${escapeXML(JSON.stringify(additionalData, null, 4))}" height="300px" width="100vh"/>
+					</m:VBox>`;
+	}
+	return xml`<m:VBox xmlns:m="sap.m" xmlns:code="sap.ui.codeeditor">
+				${errorLabels}
+				<m:HBox>
+					<m:VBox>
+						<m:Label text="How the building block was called"/>
+						<code:CodeEditor type="xml" value="${escapeXML(xmlFragment)}" height="300px" width="100vh"/>
+					</m:VBox>
+					${additionalText}
+				</m:HBox>
+			</m:VBox>`;
+}
+
+const myStore: Record<string, any> = {};
+function storeValue(values: any) {
+	const propertyUID = `uid--${uid()}`;
+	myStore[propertyUID] = values;
+	return propertyUID;
+}
+
+/**
+ * Parse an XML string and return the associated document.
+ *
+ * @param xmlString The xml string
+ * @param addDefaultNamespaces Whether or not we should add default namespace
+ * @returns The XML document.
+ */
+function parseXMLString(xmlString: string, addDefaultNamespaces = false): Element {
+	if (addDefaultNamespaces) {
+		xmlString = `<template
+						xmlns:template="http://schemas.sap.com/sapui5/extension/sap.ui.core.template/1"
+						xmlns:m="sap.m"
+						xmlns:core="sap.ui.core"
+						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?.localName === "template") {
+		output = output.firstElementChild;
+	}
+	return output as Element;
+}
+
+/**
+ * Escape an XML string to include it in an XML fragment.
+ *
+ * @param str The string to escape
+ * @returns The escaped string.
+ */
+function escapeXML(str: string): string {
+	return str
+		.replace(/&/g, "&amp;")
+		.replace(/</g, "&lt;")
+		.replace(/\n/g, "&#10;")
+		.replace(/\{/g, "\\{")
+		.replace(/>/g, "&gt;")
+		.replace(/"/g, "&quot;")
+		.replace(/'/g, "&apos;");
+}
+
+/**
+ * Escape an XML attribute value.
+ *
+ * @param val The attribute value to escape.
+ * @returns The escaped string.
+ */
+function escapeXMLAttributeValue(val: string): string {
+	return val.replace(/&/g, "&amp;").replace(/</g, "&lt;");
+}
+
+/**
+ * Create a string representation of the template literal while handling special object case.
+ *
+ * @param strings The string parts of the template literal
+ * @param values The values part of the template literal
+ * @returns The XML string document representing the string that was used.
+ */
+export const xml = (strings: TemplateStringsArray, ...values: any[]) => {
+	let outStr = "";
+	let i;
+	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 (determined by _type) then we compile it.
+		if (Array.isArray(values[i])) {
+			outStr += values[i].flat(5).join("").trim();
+		} else if (values[i]?._type) {
+			const compiledExpression = compileBinding(values[i]);
+			outStr += compiledExpression !== undefined ? escapeXMLAttributeValue(compiledExpression) : undefined;
+		} else if (values[i]?.getTemplate) {
+			outStr += values[i].getTemplate();
+		} else if (typeof values[i] === "object") {
+			const propertyUId = storeValue(values[i]);
+			outStr += `${propertyUId}`;
+		} else {
+			outStr += values[i];
+		}
+	}
+	outStr += strings[i];
+	outStr = outStr.trim();
+	if (isTraceMode) {
+		const xmlResult = parseXMLString(outStr, true);
+		if (xmlResult && xmlResult?.localName === "parsererror") {
+			const errorMessage = (xmlResult as any).innerText || (xmlResult as any).innerHTML;
+			return createErrorXML([errorMessage.split("\n")[0]], outStr);
+		}
+	}
+	return outStr;
+};