@sapui5/sap.fe.core 1.101.0 → 1.103.0

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

@@ -1,6 +1,7 @@
 import Log from "sap/base/Log";
+import uid from "sap/base/util/uid";
 import AttributeModel from "sap/fe/core/buildingBlocks/AttributeModel";
-import {
+import type {
 	BuildingBlockAggregationDefinition,
 	BuildingBlockBase,
 	BuildingBlockDefinition,
@@ -9,19 +10,23 @@ import {
 	BuildingBlockMetadataContextDefinition,
 	BuildingBlockPropertyDefinition
 } from "sap/fe/core/buildingBlocks/BuildingBlock";
+import { compileExpression } from "sap/fe/core/helpers/BindingToolkit";
 import ResourceModel from "sap/fe/macros/ResourceModel";
 import BindingParser from "sap/ui/base/BindingParser";
 import XMLPreprocessor from "sap/ui/core/util/XMLPreprocessor";
-import JSONModel from "sap/ui/model/json/JSONModel";
+import type Context from "sap/ui/model/Context";
+import type 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 = {
@@ -38,7 +43,7 @@ type ICallback = {
 	 * @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>;
 
 	/**
@@ -65,6 +70,7 @@ type ICallback = {
 	/**
 	 * 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]
@@ -77,6 +83,7 @@ type ICallback = {
 	 *   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>
@@ -165,7 +172,7 @@ export function validateMacroSignature(sName: any, oMetadata: any, mContexts: an
 		const oPropertySettings = oMetadata.properties[sKey];
 		if (!oNode.hasAttribute(sKey)) {
 			if (oPropertySettings.required && !oPropertySettings.hasOwnProperty("defaultValue")) {
-				throw new Error(sName + ": " + "Required property '" + sKey + "' is missing");
+				throw new Error(`${sName}: ` + `Required property '${sKey}' is missing`);
 			}
 		} else {
 			delete oAttributeNames[sKey];
@@ -185,9 +192,10 @@ export function validateMacroSignature(sName: any, oMetadata: any, mContexts: an
  * 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): ResolvedBuildingBlockMetadata {
+function prepareMetadata(buildingBlockMetadata?: BuildingBlockMetadata, isOpen = false): ResolvedBuildingBlockMetadata {
 	if (buildingBlockMetadata) {
 		const oProperties: any = {};
 		const oAggregations: any = {
@@ -221,7 +229,8 @@ function prepareMetadata(buildingBlockMetadata?: BuildingBlockMetadata): Resolve
 		return {
 			properties: oProperties,
 			aggregations: oAggregations,
-			metadataContexts: oMetadataContexts
+			metadataContexts: oMetadataContexts,
+			isOpen: isOpen
 		};
 	} else {
 		return {
@@ -234,12 +243,20 @@ function prepareMetadata(buildingBlockMetadata?: BuildingBlockMetadata): Resolve
 					type: "sap.ui.core.Element"
 				}
 			},
-			properties: {}
+			properties: {},
+			isOpen: isOpen
 		};
 	}
 }
 
-function _getMetadataContext(oSettings: any, oNode: Element, sAttributeName: string, oVisitor: ICallback, bDoNotResolve: boolean) {
+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;
@@ -247,7 +264,15 @@ function _getMetadataContext(oSettings: any, oNode: Element, sAttributeName: str
 		// oVisitor.getResult(sAttributeValue, oNode);
 		oMetadataContext = BindingParser.complexParser(sAttributeValue);
 		if (!oMetadataContext) {
-			if ((sAttributeName === "metaPath" && oSettings.currentContextPath) || sAttributeName === "contextPath") {
+			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;
@@ -276,6 +301,17 @@ function _getMetadataContext(oSettings: any, oNode: Element, sAttributeName: str
 			model: sAttributeName,
 			path: ""
 		};
+	} else if (isOpen) {
+		try {
+			if (oVisitor.getContext(`${sAttributeName}>`)) {
+				oMetadataContext = {
+					model: sAttributeName,
+					path: ""
+				};
+			}
+		} catch (e) {
+			oMetadataContext = undefined;
+		}
 	}
 	return oMetadataContext;
 }
@@ -319,10 +355,9 @@ async function processProperties(
 	aDefinitionContextsKeys = aDefinitionContextsKeys.sort(function (a: string, b: string) {
 		return a > b ? 1 : -1;
 	});
-	for (let j = 0; j < aDefinitionContextsKeys.length; j++) {
-		const sAttributeName = aDefinitionContextsKeys[j];
+	for (const sAttributeName of aDefinitionContextsKeys) {
 		const bDoNotResolve = isPublic && !oDefinitionContexts[sAttributeName].isPublic && oNode.hasAttribute(sAttributeName);
-		const oMetadataContext = _getMetadataContext(oSettings, oNode, sAttributeName, oVisitor, bDoNotResolve);
+		const oMetadataContext = _getMetadataContext(oSettings, oNode, sAttributeName, oVisitor, bDoNotResolve, oMetadata.isOpen);
 		if (oMetadataContext) {
 			oMetadataContext.name = sAttributeName;
 			addSingleContext(mContexts, oVisitor, oMetadataContext, oMetadataContexts);
@@ -340,7 +375,7 @@ async function processProperties(
 			mMissingContext[sAttributeName] = true;
 		}
 	}
-	return { mMissingContext, propertyValues };
+	return { mMissingContext, propertyValues: propertyValues };
 }
 
 async function processChildren(
@@ -383,43 +418,43 @@ async function processBuildingBlock(
 	oVisitor: ICallback,
 	isPublic = false
 ) {
-	try {
-		const sFragmentName = buildingBLockDefinition.fragment || `${buildingBLockDefinition.namespace}.${buildingBLockDefinition.name}`;
-
-		const sName = "this";
-
-		const mContexts: any = {};
-		const oMetadataContexts: any = {};
-		const oSettings = oVisitor.getSettings();
-		// TODO 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);
-
-		//Inject storage for macros
-		if (!oSettings[sFragmentName]) {
-			oSettings[sFragmentName] = {};
-		}
+	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);
 
-		// First of all we need to visit the attributes
-		let { mMissingContext, propertyValues } = await processProperties(
-			oMetadata,
-			oSettings,
-			oNode,
-			isPublic,
-			oVisitor,
-			mContexts,
-			oMetadataContexts
-		);
+	//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;
@@ -429,9 +464,9 @@ async function processBuildingBlock(
 			// 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) {
-			propertyValues = buildingBLockDefinition.create.call(
+			processedPropertyValues = buildingBLockDefinition.create.call(
 				buildingBLockDefinition,
 				propertyValues,
 				oControlConfig,
@@ -441,12 +476,12 @@ async function processBuildingBlock(
 			);
 			Object.keys(oMetadata.metadataContexts).forEach(function (sMetadataName: string) {
 				if (oMetadata.metadataContexts[sMetadataName].computed) {
-					mContexts[sMetadataName] = propertyValues[sMetadataName];
+					mContexts[sMetadataName] = processedPropertyValues[sMetadataName];
 				}
 			});
 			Object.keys(mMissingContext).forEach(function (sContextName: string) {
-				if (propertyValues.hasOwnProperty(sContextName)) {
-					mContexts[sContextName] = propertyValues[sContextName];
+				if (processedPropertyValues.hasOwnProperty(sContextName)) {
+					mContexts[sContextName] = processedPropertyValues[sContextName];
 				}
 			});
 		} else if (buildingBLockDefinition.apiVersion === 2) {
@@ -464,7 +499,7 @@ async function processBuildingBlock(
 			const BuildingBlockClass = buildingBLockDefinition as typeof BuildingBlockBase;
 			oInstance = new BuildingBlockClass(propertyValues /*, oControlConfig, oSettings, oAggregations, isPublic*/);
 		}
-		const oAttributesModel: JSONModel = new AttributeModel(oNode, propertyValues, buildingBLockDefinition);
+		const oAttributesModel: JSONModel = new AttributeModel(oNode, processedPropertyValues, buildingBLockDefinition);
 		mContexts[sName] = oAttributesModel.createBindingContext("/");
 
 		let oPreviousMacroInfo: any;
@@ -495,17 +530,55 @@ async function processBuildingBlock(
 				buildingBLockDefinition.apiVersion === 2
 			) {
 				let oTemplate;
+				let addDefaultNamespace = false;
 				if (buildingBLockDefinition.apiVersion === 2) {
 					oTemplate = oInstance.getTemplate();
+					addDefaultNamespace = true;
 				} else if (buildingBLockDefinition.getTemplate) {
-					oTemplate = buildingBLockDefinition.getTemplate(propertyValues);
+					oTemplate = buildingBLockDefinition.getTemplate(processedPropertyValues);
 				}
 
+				let hasError = "";
 				if (oTemplate) {
 					if (!oTemplate.firstElementChild) {
-						oTemplate = DOMParserInstance.parseFromString(oTemplate, "text/xml");
+						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.firstElementChild);
+					oNode.replaceWith(oTemplate);
 					oNode = oParent.children[iChildIndex];
 					oPromise = oContextVisitor.visitNode(oNode);
 				} else {
@@ -534,7 +607,7 @@ async function processBuildingBlock(
 							const sSlotName =
 								(oMetadata.aggregations[sAggregationName] && oMetadata.aggregations[sAggregationName].slot) ||
 								sAggregationName;
-							const oTargetElement = oMacroElement.querySelector("slot[name='" + sSlotName + "']") as Element;
+							const oTargetElement = oMacroElement.querySelector(`slot[name='${sSlotName}']`) as Element;
 							if (oTargetElement) {
 								oTargetElement.replaceWith(...(oNewChild.children as any));
 							}
@@ -550,15 +623,53 @@ async function processBuildingBlock(
 					oSlotElement.remove();
 				});
 			}
-			if (oPreviousMacroInfo) {
-				//restore macro info if available
-				oSettings["_macroInfo"] = oPreviousMacroInfo;
+		}
+		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 {
-				delete oSettings["_macroInfo"];
+				traceDetails.initialProperties[propertyName] = propertyValue;
 			}
 		}
-	} catch (e) {
-		Log.error(e as any);
+		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) {
@@ -570,7 +681,7 @@ function addSingleContext(mContexts: any, oVisitor: any, oCtx: any, oMetadataCon
 	try {
 		let sContextPath = oCtx.path;
 		if (oCtx.model != null) {
-			sContextPath = oCtx.model + ">" + sContextPath;
+			sContextPath = `${oCtx.model}>${sContextPath}`;
 		}
 		const mSetting = oVisitor.getSettings();
 		if (!mSetting.bindingContexts[oCtx.model] && mSetting.models[oCtx.model]) {
@@ -584,7 +695,7 @@ function addSingleContext(mContexts: any, oVisitor: any, oCtx: any, oMetadataCon
 		//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 not yet implemented
+		// TODO 0002 not yet implemented
 		//mContexts["_$error"].oModel.setProperty("/" + sKey, ex);
 	}
 }
@@ -609,20 +720,119 @@ export function registerBuildingBlock(buildingBlockDefinition: BuildingBlockDefi
 	}
 }
 
+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;
+}
+
 /**
- * Create an XML representation of the string used in the template literal.
+ * 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 document representing the string that was used.
+ * @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];
-		outStr += values[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 = compileExpression(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];
-	return DOMParserInstance.parseFromString(outStr, "text/xml");
+	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;
 };