@sapui5/sap.fe.core 1.111.0 → 1.112.0

package/src/sap/fe/core/buildingBlocks/{BuildingBlockRuntime.ts → BuildingBlockTemplateProcessor.ts}

@@ -1,47 +1,39 @@
-import type ResourceBundle from "sap/base/i18n/ResourceBundle";
 import Log from "sap/base/Log";
 import deepClone from "sap/base/util/deepClone";
 import uid from "sap/base/util/uid";
 import type AppComponent from "sap/fe/core/AppComponent";
 import AttributeModel from "sap/fe/core/buildingBlocks/AttributeModel";
+import type BuildingBlockBase from "sap/fe/core/buildingBlocks/BuildingBlockBase";
 import type {
 	BuildingBlockAggregationDefinition,
-	BuildingBlockBase,
-	BuildingBlockDefinition,
-	BuildingBlockDefinitionV1,
 	BuildingBlockMetadata,
 	BuildingBlockMetadataContextDefinition,
 	BuildingBlockPropertyDefinition,
 	ObjectValue,
 	ObjectValue2
-} from "sap/fe/core/buildingBlocks/BuildingBlock";
+} from "sap/fe/core/buildingBlocks/BuildingBlockSupport";
 import type { Position } from "sap/fe/core/converters/helpers/ConfigurableObject";
 import { Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
 import type { BindingToolkitExpression } from "sap/fe/core/helpers/BindingToolkit";
 import { compileExpression, isBindingToolkitExpression } from "sap/fe/core/helpers/BindingToolkit";
 import { isContext, isFunctionArray } from "sap/fe/core/helpers/TypeGuards";
-import ResourceModel from "sap/fe/macros/ResourceModel";
+import type ResourceModel from "sap/fe/core/ResourceModel";
 import BindingParser from "sap/ui/base/BindingParser";
 import type Control from "sap/ui/core/Control";
 import XMLPreprocessor from "sap/ui/core/util/XMLPreprocessor";
 import type Context from "sap/ui/model/Context";
-import type JSONModel from "sap/ui/model/json/JSONModel";
+import JSONModel from "sap/ui/model/json/JSONModel";
 import type Model from "sap/ui/model/Model";
 import type ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
-import type _ResourceModel from "sap/ui/model/resource/ResourceModel";
 import type { MacroInfo, TraceMetadataContext } from "./TraceInfo";
 import TraceInfo from "./TraceInfo";
 
-const LOGGER_SCOPE = "sap.fe.core.buildingBlocks.BuildingBlockRuntime";
+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();
-let isTraceMode = false;
 
-export type ResolvedBuildingBlockMetadata = {
-	properties: Record<string, BuildingBlockPropertyDefinition>;
-	aggregations: Record<string, BuildingBlockAggregationDefinition>;
+export type TransformedBuildingBlockMetadata = BuildingBlockMetadata & {
 	metadataContexts: Record<string, BuildingBlockMetadataContextDefinition>;
-	isOpen: boolean;
-	defaultAggregation?: string;
 };
 
 /**
@@ -61,7 +53,7 @@ export type TemplateProcessorSettings = {
 		converterContext: JSONModel;
 		viewData: JSONModel;
 		metaModel: ODataMetaModel;
-		"sap.fe.i18n"?: _ResourceModel;
+		"sap.fe.i18n"?: ResourceModel;
 	};
 	bindingContexts: Record<string, Context>;
 	_macroInfo?: MacroInfo;
@@ -77,9 +69,9 @@ export type IVisitorCallback = {
 	 * and {@link sap.ui.core.util.XMLPreprocessor.ICallback.visitChildNodes
 	 * visitChildNodes}.
 	 *
-	 * @param {Node} oNode
+	 * @param oNode
 	 *   The XML DOM node
-	 * @returns {sap.ui.base.SyncPromise}
+	 * @returns
 	 *   A thenable which resolves with <code>undefined</code> as soon as visiting
 	 *   is done, or is rejected with a corresponding error if visiting fails
 	 */
@@ -92,13 +84,13 @@ export type IVisitorCallback = {
 	 * put into place. Loading of fragments is asynchronous if the template view is
 	 * asynchronous.
 	 *
-	 * @param {string} sFragmentName
+	 * @param sFragment
 	 *   the fragment's resolved name
-	 * @param {Element} oElement
+	 * @param oElement
 	 *   the XML DOM element, e.g. <sap.ui.core:Fragment> or <core:ExtensionPoint>
-	 * @param {sap.ui.core.util._with} oWithControl
+	 * @param oWith
 	 *   the parent's "with" control
-	 * @returns {sap.ui.base.SyncPromise}
+	 * @returns
 	 * 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.
@@ -112,12 +104,12 @@ export type IVisitorCallback = {
 	 * Interprets the given XML DOM attribute value as a binding and returns the
 	 * resulting value.
 	 *
-	 * @param {string} sValue
+	 * @param sValue
 	 *   An XML DOM attribute value
-	 * @param {Element} [oElement]
+	 * @param [element]
 	 *   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}
+	 * @returns
 	 *   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
@@ -133,12 +125,12 @@ export type IVisitorCallback = {
 	 * 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]
+	 * @param [mVariables={}]
+	 *   Map from variable name (string) to value
+	 * @param [bReplace]
 	 *   Whether only the given variables are known in the new callback interface
 	 *   instance, no inherited ones
-	 * @returns {sap.ui.core.util.XMLPreprocessor.ICallback}
+	 * @returns
 	 *   A callback interface instance
 	 * @param mVariables
 	 * @param bReplace
@@ -146,16 +138,6 @@ export type IVisitorCallback = {
 	"with"(mVariables?: Record<string, Context>, bReplace?: boolean): IVisitorCallback;
 };
 
-/**
- * Typeguard for checking if a building block uses 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: Record<string, Context>,
@@ -196,7 +178,7 @@ function validateMacroMetadataContext(
 }
 export function validateMacroSignature(
 	sName: string,
-	oMetadata: ResolvedBuildingBlockMetadata,
+	oMetadata: TransformedBuildingBlockMetadata,
 	mContexts: Record<string, Context>,
 	oNode: Element
 ) {
@@ -243,78 +225,46 @@ const SAP_UI_CORE_ELEMENT = "sap.ui.core.Element";
 export const SAP_UI_MODEL_CONTEXT = "sap.ui.model.Context";
 
 /**
- * Ensures that the metadata for the building block are properly defined.
+ * 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
- * @param isOpen Whether the building block is open or not
- * @param apiVersion
- * @returns A set of completed metadata for further processing
+ * @returns The transformed metadata
  */
-function prepareMetadata(
-	buildingBlockMetadata?: BuildingBlockMetadata,
-	isOpen = false,
-	apiVersion?: number
-): ResolvedBuildingBlockMetadata {
-	if (buildingBlockMetadata) {
-		const oProperties: Record<string, BuildingBlockPropertyDefinition> = {};
-		const oAggregations: Record<string, BuildingBlockAggregationDefinition> = {
-			dependents: {
-				type: SAP_UI_CORE_ELEMENT
-			},
-			customData: {
-				type: SAP_UI_CORE_ELEMENT
-			}
-		};
+function transformMetadata(buildingBlockMetadata: BuildingBlockMetadata): TransformedBuildingBlockMetadata {
+	const properties: Record<string, BuildingBlockPropertyDefinition> = {};
+	const aggregations: Record<string, BuildingBlockAggregationDefinition> = {
+		dependents: {
+			type: SAP_UI_CORE_ELEMENT,
+			slot: "dependents"
+		},
+		customData: {
+			type: SAP_UI_CORE_ELEMENT,
+			slot: "customData"
+		},
+		...buildingBlockMetadata.aggregations
+	};
+	const metadataContexts: Record<string, BuildingBlockPropertyDefinition> = {};
 
-		if (apiVersion === 2) {
-			oAggregations.dependents.slot = "dependents";
-		}
+	for (const propertyName of Object.keys(buildingBlockMetadata.properties)) {
+		const propertyType = buildingBlockMetadata.properties[propertyName].type;
 
-		const oMetadataContexts: Record<string, BuildingBlockPropertyDefinition> = {};
-		let foundDefaultAggregation;
-		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 !== undefined) {
-			Object.keys(buildingBlockMetadata.events).forEach(function (sEventName: string) {
-				oProperties[sEventName] = { type: "function", ...buildingBlockMetadata.events[sEventName] };
-			});
+		if (propertyType !== SAP_UI_MODEL_CONTEXT) {
+			properties[propertyName] = buildingBlockMetadata.properties[propertyName];
 		}
-		if (buildingBlockMetadata.aggregations !== undefined) {
-			Object.keys(buildingBlockMetadata.aggregations).forEach(function (sPropertyName: string) {
-				oAggregations[sPropertyName] = buildingBlockMetadata.aggregations[sPropertyName];
-				if (oAggregations[sPropertyName].isDefault) {
-					foundDefaultAggregation = sPropertyName;
-				}
-			});
+
+		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 {
-			properties: oProperties,
-			aggregations: oAggregations,
-			defaultAggregation: foundDefaultAggregation,
-			metadataContexts: oMetadataContexts,
-			isOpen: isOpen
-		};
-	} else {
-		return {
-			metadataContexts: {},
-			aggregations: {
-				dependents: {
-					type: SAP_UI_CORE_ELEMENT
-				},
-				customData: {
-					type: SAP_UI_CORE_ELEMENT
-				}
-			},
-			properties: {},
-			isOpen: isOpen
-		};
 	}
+
+	return {
+		...buildingBlockMetadata,
+		properties,
+		metadataContexts,
+		aggregations
+	};
 }
 
 /**
@@ -356,14 +306,13 @@ function _createInitialMetadataContext(
 	sAttributeValue: string
 ): MetaDataContext {
 	let returnContext: MetaDataContext;
-	if (sAttributeValue.startsWith("/uid--")) {
-		const oData = myStore[sAttributeValue];
-		oSettings.models.converterContext.setProperty(sAttributeValue, oData);
+	if (sAttributeValue.startsWith("/uid--") && !oSettings.models.converterContext.getProperty(sAttributeValue)) {
+		const data = unstoreObjectValue(sAttributeValue);
+		oSettings.models.converterContext.setProperty(sAttributeValue, data);
 		returnContext = {
 			model: "converterContext",
 			path: sAttributeValue
 		};
-		delete myStore[sAttributeValue];
 	} else if ((sAttributeName === "metaPath" && oSettings.currentContextPath) || sAttributeName === "contextPath") {
 		returnContext = _checkAbsoluteAndContextPaths(oSettings, sAttributeValue);
 	} else if (sAttributeValue && sAttributeValue.startsWith("/")) {
@@ -423,14 +372,12 @@ function _getMetadataContext(
  * @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 apiVersion The API version of the building block
  */
 async function processProperties(
-	oMetadata: ResolvedBuildingBlockMetadata,
+	oMetadata: TransformedBuildingBlockMetadata,
 	oNode: Element,
 	isPublic: boolean,
-	oVisitor: IVisitorCallback,
-	apiVersion?: number
+	oVisitor: IVisitorCallback
 ) {
 	const oDefinitionProperties = oMetadata.properties;
 
@@ -440,7 +387,8 @@ async function processProperties(
 	const propertyValues: Record<string, ObjectValue> = {};
 	for (const sKeyValue of aDefinitionPropertiesKeys) {
 		if (oDefinitionProperties[sKeyValue].type === "object") {
-			propertyValues[sKeyValue] = deepClone(oDefinitionProperties[sKeyValue].defaultValue || {}); // To avoid values being reused across macros
+			propertyValues[sKeyValue] =
+				oDefinitionProperties[sKeyValue].defaultValue && deepClone(oDefinitionProperties[sKeyValue].defaultValue); // To avoid values being reused across macros
 		} else {
 			propertyValues[sKeyValue] = oDefinitionProperties[sKeyValue].defaultValue as string | boolean | number;
 		}
@@ -451,7 +399,7 @@ async function processProperties(
 			await oVisitor.visitAttribute(oNode, oNode.attributes.getNamedItem(sKeyValue) as Attr);
 			let value: string | boolean | number | null | undefined = oNode.getAttribute(sKeyValue);
 			if (value !== undefined && value !== null) {
-				if (apiVersion === 2 && typeof value === "string" && !value.startsWith("{")) {
+				if (typeof value === "string" && !value.startsWith("{")) {
 					switch (oDefinitionProperties[sKeyValue].type) {
 						case "boolean":
 							value = value === "true";
@@ -478,21 +426,20 @@ async function processProperties(
  * @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 oMetadataContexts	The metadata contexts to be used
+ * @param propertyValues The current property values
  * @returns The processed and missing contexts
  */
 function processContexts(
-	oMetadata: ResolvedBuildingBlockMetadata,
+	oMetadata: TransformedBuildingBlockMetadata,
 	oSettings: TemplateProcessorSettings,
 	oNode: Element,
 	isPublic: boolean,
 	oVisitor: IVisitorCallback,
 	mContexts: Record<string, Context>,
-	oMetadataContexts: Record<string, Context>
+	propertyValues: Record<string, ObjectValue>
 ) {
 	oSettings.currentContextPath = oSettings.bindingContexts.contextPath;
 	const mMissingContext: Record<string, boolean> = {};
-	const propertyValues: Record<string, unknown> = {};
 	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
@@ -503,11 +450,17 @@ function processContexts(
 		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 as object).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);
+		const oMetadataContext = _getMetadataContext(oSettings, oNode, sAttributeName, oVisitor, bDoNotResolve, oMetadata.isOpen ?? false);
 		if (oMetadataContext) {
 			oMetadataContext.name = sAttributeName;
-			addSingleContext(mContexts, oVisitor, oMetadataContext, oMetadataContexts);
+			addSingleContext(mContexts, oVisitor, oMetadataContext);
 			if (
 				(sAttributeName === "entitySet" || sAttributeName === "contextPath") &&
 				!oSettings.bindingContexts.hasOwnProperty(sAttributeName)
@@ -517,12 +470,17 @@ function processContexts(
 			if (sAttributeName === "contextPath") {
 				oSettings.currentContextPath = mContexts[sAttributeName];
 			}
-			propertyValues[sAttributeName] = 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, propertyValues: propertyValues };
+	return mMissingContext;
 }
 
 export type BuildingBlockAggregation = {
@@ -552,6 +510,8 @@ function parseAggregation(oAggregation?: Element, processAggregations?: Function
 					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`);
 			}
 		}
 	}
@@ -566,21 +526,31 @@ function parseAggregation(oAggregation?: Element, processAggregations?: Function
  * @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
- * @param apiVersion The API version of the building block
  */
 async function processChildren(
 	oNode: Element,
 	oVisitor: IVisitorCallback,
-	oMetadata: ResolvedBuildingBlockMetadata,
+	oMetadata: TransformedBuildingBlockMetadata,
 	isPublic: boolean,
-	propertyValues: Record<string, ObjectValue>,
-	apiVersion?: number
+	propertyValues: Record<string, ObjectValue>
 ) {
 	const oAggregations: Record<string, Element> = {};
 	if (oNode.firstElementChild !== null) {
 		let oFirstElementChild: Element | null = oNode.firstElementChild as Element | null;
-		if (apiVersion === 2) {
-			while (oFirstElementChild !== null) {
+
+		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]) {
@@ -599,10 +569,6 @@ async function processChildren(
 			}
 		}
 
-		if (apiVersion !== 2) {
-			// If there are aggregation we need to visit the childNodes to resolve templating instructions
-			await oVisitor.visitChildNodes(oNode);
-		}
 		oFirstElementChild = oNode.firstElementChild;
 		while (oFirstElementChild !== null) {
 			const oNextChild: Element | null = oFirstElementChild.nextElementSibling;
@@ -616,38 +582,34 @@ async function processChildren(
 				Object.keys(oMetadata.aggregations).indexOf(sAggregationName) !== -1 &&
 				(!isPublic || oMetadata.aggregations[sAggregationName].isPublic === true)
 			) {
-				if (apiVersion === 2) {
-					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) {
-						if (sAggregationName !== sChildName) {
-							if (!oAggregations[sAggregationName]) {
-								const oNewChild = document.createElementNS(oNode.namespaceURI, sAggregationName);
-								oAggregations[sAggregationName] = oNewChild;
-							}
-							oAggregations[sAggregationName].appendChild(oFirstElementChild);
+				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[sAggregationName] = oFirstElementChild;
+							oAggregations[childDefinition.getAttribute("key")!] = childDefinition;
 						}
+
+						childDefinition.removeAttribute("key");
+						childDefinition = nextChild;
 					}
-				} else {
+				} else if (aggregationDefinition.slot) {
 					await oVisitor.visitNode(oFirstElementChild);
-					oAggregations[oFirstElementChild.localName] = 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);
@@ -738,31 +700,20 @@ function prepareAggregationElement(oNode: Element, sAggregationName: string, oEl
 }
 
 async function processBuildingBlock(
-	buildingBlockDefinition: BuildingBlockDefinition,
+	BuildingBlockClass: typeof BuildingBlockBase,
 	oNode: Element,
 	oVisitor: IVisitorCallback,
 	isPublic = false
 ) {
-	const sFragmentName =
-		buildingBlockDefinition.fragment ||
-		`${buildingBlockDefinition.namespace}.${buildingBlockDefinition.xmlTag || buildingBlockDefinition.name}`;
+	const oMetadata = transformMetadata(BuildingBlockClass.metadata);
 
-	const sName = "this";
+	const sFragmentName = oMetadata.fragment || `${oMetadata.namespace}.${oMetadata.xmlTag || oMetadata.name}`;
 
 	const mContexts: Record<string, Context> = {};
-	const oMetadataContexts: Record<string, Context> = {};
 	const oSettings = oVisitor.getSettings();
-	// TODO 0001 Move this elsewhere this is weird :)
-	if (oSettings.models["sap.fe.i18n"]) {
-		(oSettings.models["sap.fe.i18n"].getResourceBundle() as Promise<ResourceBundle>)
-			.then(function (oResourceBundle: ResourceBundle) {
-				ResourceModel.setApplicationI18nBundle(oResourceBundle);
-			})
-			.catch(function (error: unknown) {
-				Log.error(error as string);
-			});
-	}
-	const oMetadata = prepareMetadata(buildingBlockDefinition.metadata, buildingBlockDefinition.isOpen, buildingBlockDefinition.apiVersion);
+
+	// 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]) {
@@ -770,30 +721,13 @@ async function processBuildingBlock(
 	}
 
 	// First of all we need to visit the attributes to resolve the properties and the metadata contexts
-	let propertyValues = await processProperties(oMetadata, oNode, isPublic, oVisitor, buildingBlockDefinition.apiVersion);
-
-	const { mMissingContext, propertyValues: extraPropertyValues } = processContexts(
-		oMetadata,
-		oSettings,
-		oNode,
-		isPublic,
-		oVisitor,
-		mContexts,
-		oMetadataContexts
-	);
-	propertyValues = Object.assign(propertyValues, extraPropertyValues);
+	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,
-			buildingBlockDefinition.apiVersion
-		);
-		let oInstance: BuildingBlockBase | undefined;
+		const oAggregations = await processChildren(oNode, oVisitor, oMetadata, isPublic, propertyValues);
 		let oControlConfig = {};
 
 		if (oSettings.models.viewData) {
@@ -801,64 +735,39 @@ async function processBuildingBlock(
 			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 === true) {
-					mContexts[sMetadataName] = processedPropertyValues[sMetadataName] as unknown as Context;
-				}
-			});
-			Object.keys(mMissingContext).forEach(function (sContextName: string) {
-				if (processedPropertyValues.hasOwnProperty(sContextName)) {
-					mContexts[sContextName] = processedPropertyValues[sContextName] as unknown as Context;
-				}
-			});
-		} else if (buildingBlockDefinition.apiVersion === 2) {
-			Object.keys(propertyValues).forEach((propName) => {
-				let oData = propertyValues[propName] as unknown as Context;
-				//check for additional processing function to validate / overwrite parameters
-				const originalDefinition = buildingBlockDefinition?.metadata?.properties[propName];
-				if (originalDefinition?.validate) {
-					oData = originalDefinition.validate(oData) || oData;
-				}
-				if (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;
-			propertyValues.isPublic = isPublic;
-
-			oInstance = new BuildingBlockClass(
-				{ ...propertyValues, ...oAggregations },
-				oControlConfig,
-				oSettings
-				/*, oControlConfig, oSettings, oAggregations, isPublic*/
-			);
-			processedPropertyValues = oInstance.getProperties();
-			Object.keys(oMetadata.metadataContexts).forEach(function (sContextName: string) {
-				if (processedPropertyValues.hasOwnProperty(sContextName)) {
-					const targetObject = processedPropertyValues[sContextName];
-					if (typeof targetObject === "object" && !isContext(targetObject)) {
-						const sAttributeValue = storeValue(targetObject);
-						oSettings.models.converterContext.setProperty(sAttributeValue, targetObject);
-						const newContext = oSettings.models.converterContext.createBindingContext(sAttributeValue)!;
-						delete myStore[sAttributeValue];
-						mContexts[sContextName] = newContext;
-					} else if (!mContexts.hasOwnProperty(sContextName) && targetObject !== undefined) {
-						mContexts[sContextName] = targetObject as Context;
-					}
+
+		Object.keys(propertyValues).forEach((propName) => {
+			let oData = propertyValues[propName] as unknown as Context;
+			//check for additional processing function to validate / overwrite parameters
+			const originalDefinition = BuildingBlockClass?.metadata?.properties[propName];
+			if (originalDefinition?.validate) {
+				oData = originalDefinition.validate(oData) || oData;
+			}
+			if (oData?.isA?.(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: string) {
+			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 as Context;
 				}
-			});
-		}
-		const oAttributesModel: JSONModel = new AttributeModel(oNode, processedPropertyValues, buildingBlockDefinition);
-		mContexts[sName] = oAttributesModel.createBindingContext("/");
+			}
+		});
+
+		const oAttributesModel: JSONModel = new AttributeModel(oNode, processedPropertyValues, BuildingBlockClass);
+		mContexts["this"] = oAttributesModel.createBindingContext("/");
 		let oPreviousMacroInfo: MacroInfo | undefined;
 
 		// Keep track
@@ -871,42 +780,31 @@ async function processBuildingBlock(
 		}
 		validateMacroSignature(sFragmentName, oMetadata, mContexts, oNode);
 
-		const oContextVisitor = oVisitor.with(
-			mContexts,
-			buildingBlockDefinition.isOpen !== undefined ? !buildingBlockDefinition.isOpen : true
-		);
+		const oContextVisitor = oVisitor.with(mContexts, oMetadata.isOpen !== undefined ? !oMetadata.isOpen : true);
 		const oParent = oNode.parentNode;
 
 		let iChildIndex: number;
 		let oPromise;
-		let processCustomData = true;
 		if (oParent) {
 			iChildIndex = Array.from(oParent.children).indexOf(oNode);
-			if (
-				(isV1MacroDef(buildingBlockDefinition) && buildingBlockDefinition.getTemplate) ||
-				(buildingBlockDefinition.apiVersion === 2 && !buildingBlockDefinition.fragment)
-			) {
-				let templateString: string | undefined;
-				let addDefaultNamespace = false;
-				if (buildingBlockDefinition.apiVersion === 2 && oInstance !== undefined) {
-					templateString = await oInstance.getTemplate!(oNode);
-					if (buildingBlockDefinition.isRuntime === true) {
-						// For runtime building blocks, we need to attach all objects to the converterContext directly, as the actual rendering takes place at runtime
-						for (const myStoreKey in myStore) {
-							const oData = myStore[myStoreKey];
-							oSettings.models.converterContext.setProperty(myStoreKey, oData);
-							delete myStore[myStoreKey];
-						}
+
+			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);
 					}
-					addDefaultNamespace = true;
-				} else if (buildingBlockDefinition.getTemplate) {
-					templateString = await buildingBlockDefinition.getTemplate(processedPropertyValues);
 				}
 
 				let hasError = "";
 				if (templateString) {
 					let hasParseError = false;
-					let parsedTemplate = parseXMLString(templateString, addDefaultNamespace);
+					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);
@@ -926,26 +824,17 @@ async function processBuildingBlock(
 						// 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 ${buildingBlockDefinition.xmlTag || buildingBlockDefinition.name}`
-						);
-						try {
-							isTraceMode = true;
-							const initialTemplate = oInstance?.getTemplate
-								? await oInstance.getTemplate(oNode)
-								: await buildingBlockDefinition.getTemplate!(processedPropertyValues);
-							parsedTemplate = parseXMLString(initialTemplate, true);
-						} finally {
-							isTraceMode = false;
-						}
+						Log.error(`Error while processing building block ${oMetadata.xmlTag || oMetadata.name}`);
+						parsedTemplate = await processXmlInTrace(async () => {
+							const initialTemplate = await oInstance.getTemplate?.(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 ${buildingBlockDefinition.xmlTag || buildingBlockDefinition.name}`
-						);
+						Log.error(`Error while processing building block ${oMetadata.xmlTag || oMetadata.name}`);
 						const oErrorText = createErrorXML(
 							[
-								`Error while processing building block ${buildingBlockDefinition.xmlTag || buildingBlockDefinition.name}`,
+								`Error while processing building block ${oMetadata.xmlTag || oMetadata.name}`,
 								`Trailing text was found in the XML: ${hasError}`
 							],
 							parsedTemplate.map((template) => template.outerHTML).join("\n")
@@ -954,20 +843,18 @@ async function processBuildingBlock(
 					}
 					oNode.replaceWith(...parsedTemplate);
 					oNode = oParent.children[iChildIndex];
-					processSlots(oAggregations, oMetadata.aggregations, oNode, processCustomData);
-					processCustomData = false;
+					processSlots(oAggregations, oMetadata.aggregations, oNode, false);
+
 					oPromise = oContextVisitor.visitNode(oNode);
 				} else {
 					oNode.remove();
 					oPromise = Promise.resolve();
 				}
-			} else {
-				oPromise = oContextVisitor.insertFragment(sFragmentName, oNode);
 			}
 
 			await oPromise;
 			const oMacroElement = oParent.children[iChildIndex];
-			processSlots(oAggregations, oMetadata.aggregations, oMacroElement, processCustomData);
+			processSlots(oAggregations, oMetadata.aggregations, oMacroElement, true);
 			if (oMacroElement !== undefined) {
 				const oRemainingSlots = oMacroElement.querySelectorAll("slot");
 				oRemainingSlots.forEach(function (oSlotElement) {
@@ -1014,7 +901,7 @@ async function processBuildingBlock(
 		}
 		Log.error(e as string);
 		const oError = createErrorXML(
-			[`Error while processing building block ${buildingBlockDefinition.name}`],
+			[`Error while processing building block ${oMetadata.name}`],
 			oNode.outerHTML,
 			traceDetails,
 			(e as Error).stack
@@ -1030,11 +917,10 @@ function addSingleContext(
 		name?: string;
 		path: string;
 		model?: string;
-	},
-	oMetadataContexts: Record<string, Context | undefined>
+	}
 ) {
 	const sKey = (oCtx.name || oCtx.model || undefined) as string;
-	if (oMetadataContexts[sKey]) {
+	if (mContexts[sKey]) {
 		return; // do not add twice
 	}
 	try {
@@ -1050,33 +936,50 @@ function addSingleContext(
 		} 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);
+		// 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 buildingBlockDefinition The building block definition
+ * @param BuildingBlockClass The building block definition
  */
-export function registerBuildingBlock(buildingBlockDefinition: BuildingBlockDefinition): void {
+export function registerBuildingBlock(BuildingBlockClass: typeof BuildingBlockBase): void {
 	XMLPreprocessor.plugIn(
-		async (oNode: Element, oVisitor: IVisitorCallback) => processBuildingBlock(buildingBlockDefinition, oNode, oVisitor),
-		buildingBlockDefinition.namespace,
-		buildingBlockDefinition.xmlTag || buildingBlockDefinition.name
+		async (oNode: Element, oVisitor: IVisitorCallback) => processBuildingBlock(BuildingBlockClass, oNode, oVisitor),
+		BuildingBlockClass.metadata.namespace,
+		BuildingBlockClass.metadata.xmlTag || BuildingBlockClass.metadata.name
 	);
-	if (buildingBlockDefinition.publicNamespace) {
+	if (BuildingBlockClass.metadata.publicNamespace) {
+		XMLPreprocessor.plugIn(
+			async (oNode: Element, oVisitor: IVisitorCallback) => 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
+ */
+export function unregisterBuildingBlock(BuildingBlockClass: typeof BuildingBlockBase): void {
+	if (BuildingBlockClass.metadata.namespace !== undefined) {
 		XMLPreprocessor.plugIn(
-			async (oNode: Element, oVisitor: IVisitorCallback) => processBuildingBlock(buildingBlockDefinition, oNode, oVisitor, true),
-			buildingBlockDefinition.publicNamespace,
-			buildingBlockDefinition.xmlTag || buildingBlockDefinition.name
+			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
 		);
 	}
 }
@@ -1095,26 +998,67 @@ function createErrorXML(errorMessages: string[], xmlFragment: string, additional
 						<code:CodeEditor type="json"  value="${`{= BBF.base64Decode('${btoa(JSON.stringify(additionalData, null, 4))}') }`}" height="300px" />
 					</m:VBox>`;
 	}
-	return xml`<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" />
+	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>
-					${additionalText}
-				</grid:CSSGrid>
-			</m:VBox>`;
+				</controls:FormElementWrapper>`;
 }
 
-const myStore: Record<string, unknown> = {};
-function storeValue(values: unknown) {
+const temporaryObjectStore: Record<string, unknown> = {};
+
+/**
+ * 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: unknown) {
 	const propertyUID = `/uid--${uid()}`;
-	myStore[propertyUID] = values;
+	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: string) {
+	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: Function) {
+	processNextXmlInTrace = true;
+	let returnValue;
+	try {
+		returnValue = method();
+	} finally {
+		processNextXmlInTrace = false;
+	}
+	return returnValue;
+};
+
 /**
  * Parse an XML string and return the associated document.
  *
@@ -1205,7 +1149,7 @@ export const xml = (strings: TemplateStringsArray, ...values: XMLProcessorTypeVa
 			if (isContext(value)) {
 				outStr += value.getPath();
 			} else {
-				const propertyUId = storeValue(value);
+				const propertyUId = storeObjectValue(value);
 				outStr += `${propertyUId}`;
 			}
 		} else if (value && typeof value === "string" && !value.startsWith("<") && !value.startsWith("&lt;")) {
@@ -1216,7 +1160,7 @@ export const xml = (strings: TemplateStringsArray, ...values: XMLProcessorTypeVa
 	}
 	outStr += strings[i];
 	outStr = outStr.trim();
-	if (isTraceMode) {
+	if (processNextXmlInTrace) {
 		return renderInTraceMode(outStr);
 	}
 	return outStr;