@sapui5/sap.fe.core 1.98.0 → 1.101.0

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

@@ -0,0 +1,436 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/ui/base/ManagedObject", "sap/ui/core/util/XMLPreprocessor"], function (ManagedObject, XMLPreprocessor) {
+  "use strict";
+
+  //Trace information
+  var aTraceInfo = [
+    /* Structure for a macro
+    		{
+    			macro: '', //name of macro
+    			metaDataContexts: [ //Properties of type sap.ui.model.Context
+    				{
+    					name: '', //context property name / key
+    					path: '', //from oContext.getPath()
+    				}
+    			],
+    			properties: { // Other properties which become part of {this>}
+    				property1: value,
+    				property2: value
+    			}
+    			viewInfo: {
+    				viewInfo: {} // As specified in view or fragement creation
+    			},
+    			traceID: this.index, //ID for this trace information,
+    			macroInfo: {
+    				macroID: index, // traceID of this macro (redundant for macros)
+    				parentMacroID, index // traceID of the parent macro (if it has a parent)
+    			}
+    		}
+    		// Structure for a control
+    		{
+    			control: '', //control class
+    			properties: { // Other properties which become part of {this>}
+    				property1: {
+    					originalValue: '', //Value before templating
+    					resolvedValue: '' //Value after templating
+    				}
+    			}
+    			contexts: { //Models and Contexts used during templating
+    				// Model or context name used for this control
+    				modelName1: { // For ODataMetaModel
+    					path1: {
+    						path: '', //absolut path within metamodel
+    						data: '', //data of path unless type Object
+    					}
+    				modelName2: {
+    					// for other model types
+    					{
+    						property1: value,
+    						property2: value
+    					}
+    					// In case binding cannot be resolved -> mark as runtime binding
+    					// This is not always true, e.g. in case the path is metamodelpath
+    					{
+    						"bindingFor": "Runtime"
+    					}
+    				}
+    			},
+    			viewInfo: {
+    				viewInfo: {} // As specified in view or fragement creation
+    			},
+    			macroInfo: {
+    				macroID: index, // traceID of the macro that created this control
+    				parentMacroID, index // traceID of the macro's parent macro
+    			},
+    			traceID: this.index //ID for this trace information
+    		}
+    		*/
+  ];
+  var traceNamespace = "http://schemas.sap.com/sapui5/extension/sap.fe.info/1",
+      xmlns = "http://www.w3.org/2000/xmlns/",
+
+  /**
+   * Switch is currently based on url parameter
+   */
+  traceIsOn = location.search.indexOf("sap-ui-xx-feTraceInfo=true") > -1,
+
+  /**
+   * Specify all namespaces that shall be traced during templating
+   */
+  aNamespaces = ["sap.m", "sap.uxap", "sap.ui.unified", "sap.f", "sap.ui.table", "sap.suite.ui.microchart", "sap.ui.layout.form", "sap.ui.mdc", "sap.ui.mdc.link", "sap.ui.mdc.field", "sap.fe.fpm"],
+      oCallbacks = {};
+
+  function fnClone(oObject) {
+    return JSON.parse(JSON.stringify(oObject));
+  }
+
+  function collectContextInfo(sValue, oContexts, oVisitor, oNode) {
+    var aContexts;
+    var aPromises = [];
+
+    try {
+      aContexts = ManagedObject.bindingParser(sValue, undefined, false, true) || [];
+    } catch (e) {
+      aContexts = [];
+    }
+
+    aContexts = Array.isArray(aContexts) ? aContexts : [aContexts];
+    aContexts.filter(function (oContext) {
+      return oContext.path || oContext.parts;
+    }).forEach(function (oContext) {
+      var aParts = oContext.parts || [oContext];
+      aParts.filter(function (oContext) {
+        return oContext.path;
+      }).forEach(function (oContext) {
+        var oModel = oContexts[oContext.model] = oContexts[oContext.model] || {};
+        var sSimplePath = oContext.path.indexOf(">") < 0 ? (oContext.model && oContext.model + ">") + oContext.path : oContext.path;
+        var oRealContext;
+        var aParts;
+
+        if (typeof oContext.model === "undefined" && sSimplePath.indexOf(">") > -1) {
+          aParts = sSimplePath.split(">");
+          oContext.model = aParts[0];
+          oContext.path = aParts[1];
+        }
+
+        try {
+          oRealContext = oVisitor.getContext(sSimplePath);
+          aPromises.push(oVisitor.getResult("{" + sSimplePath + "}", oNode).then(function (oResult) {
+            if (oRealContext.getModel().getMetadata().getName() === "sap.ui.model.json.JSONModel") {
+              if (!oResult.oModel) {
+                oModel[oContext.path] = oResult; //oRealContext.getObject(oContext.path);
+              } else {
+                oModel[oContext.path] = "Context from " + oResult.getPath();
+              }
+            } else {
+              oModel[oContext.path] = {
+                path: oRealContext.getPath(),
+                data: typeof oResult === "object" ? "[ctrl/cmd-click] on path to see data" : oResult
+              };
+            }
+          }).catch(function () {
+            oModel[oContext.path] = {
+              bindingFor: "Runtime"
+            };
+          }));
+        } catch (exc) {
+          oModel[oContext.path] = {
+            bindingFor: "Runtime"
+          };
+        }
+      });
+    });
+    return Promise.all(aPromises);
+  }
+
+  function fillAttributes(oResults, oAttributes, sName, sValue) {
+    return oResults.then(function (result) {
+      oAttributes[sName] = sValue !== result ? {
+        originalValue: sValue,
+        resolvedValue: result
+      } : sValue;
+    }).catch(function (e) {
+      oAttributes[sName] = {
+        originalValue: sValue,
+        error: e.stack && e.stack.toString() || e
+      };
+    });
+  }
+
+  function collectInfo(oNode, oVisitor) {
+    var oAttributes = {};
+    var aPromises = [];
+    var oContexts = {};
+    var oResults;
+
+    for (var i = oNode.attributes.length >>> 0; i--;) {
+      var oAttribute = oNode.attributes[i],
+          sName = oAttribute.nodeName,
+          sValue = oNode.getAttribute(sName);
+
+      if (!["core:require"].includes(sName)) {
+        aPromises.push(collectContextInfo(sValue, oContexts, oVisitor, oNode));
+        oResults = oVisitor.getResult(sValue, oNode);
+
+        if (oResults) {
+          aPromises.push(fillAttributes(oResults, oAttributes, sName, sValue));
+        } else {//What
+        }
+      }
+    }
+
+    return Promise.all(aPromises).then(function () {
+      return {
+        properties: oAttributes,
+        contexts: oContexts
+      };
+    });
+  }
+
+  function resolve(oNode, oVisitor) {
+    var sControlName = oNode.nodeName.split(":")[1] || oNode.nodeName,
+        bIsControl = /^[A-Z]/.test(sControlName),
+        oTraceMetadataContext = {
+      control: oNode.namespaceURI + "." + (oNode.nodeName.split(":")[1] || oNode.nodeName)
+    };
+
+    if (bIsControl) {
+      if (!oNode.ownerDocument.firstChild.getAttribute("xmlns:trace")) {
+        oNode.ownerDocument.firstChild.setAttributeNS(xmlns, "xmlns:trace", traceNamespace);
+        oNode.ownerDocument.firstChild.setAttributeNS(traceNamespace, "trace:is", "on");
+      }
+
+      return collectInfo(oNode, oVisitor).then(function (result) {
+        var bRelevant = Object.keys(result.contexts).length > 0; //If no context was used it is not relevant so we ignore Object.keys(result.properties).length
+
+        if (bRelevant) {
+          Object.assign(oTraceMetadataContext, result);
+          oTraceMetadataContext.viewInfo = oVisitor.getViewInfo();
+          oTraceMetadataContext.macroInfo = oVisitor.getSettings()["_macroInfo"];
+          oTraceMetadataContext.traceID = aTraceInfo.length;
+          oNode.setAttributeNS(traceNamespace, "trace:traceID", oTraceMetadataContext.traceID);
+          aTraceInfo.push(oTraceMetadataContext);
+        }
+
+        return oVisitor.visitAttributes(oNode).then(function () {
+          return oVisitor.visitChildNodes(oNode);
+        });
+      }).catch(function (exc) {
+        oTraceMetadataContext.error = {
+          exception: exc,
+          node: new XMLSerializer().serializeToString(oNode)
+        };
+      });
+    } else {
+      return oVisitor.visitAttributes(oNode).then(function () {
+        return oVisitor.visitChildNodes(oNode);
+      });
+    }
+  }
+  /**
+   * Register path-through XMLPreprocessor plugin for all namespaces
+   * given above in aNamespaces
+   */
+
+
+  if (traceIsOn) {
+    aNamespaces.forEach(function (namespace) {
+      oCallbacks[namespace] = XMLPreprocessor.plugIn(resolve.bind(namespace), namespace);
+    });
+  }
+  /**
+   * Adds information about the processing of one macro to the collection.
+   *
+   * @name sap.fe.macros.TraceInfo.traceMacroCalls
+   * @param {string} sName Macro class name
+   * @param {object} oMetadata Definition from (macro).metadata.js
+   * @param {object} mContexts Available named contexts
+   * @param {XMLNode} oNode
+   * @param {object} oVisitor
+   * @returns {object}
+   * @private
+   * @ui5-restricted
+   * @static
+   */
+
+
+  function traceMacroCalls(sName, oMetadata, mContexts, oNode, oVisitor) {
+    var aMetadataContextKeys = oMetadata.metadataContexts && Object.keys(oMetadata.metadataContexts) || [];
+    var aProperties = oMetadata.properties && Object.keys(oMetadata.properties) || [];
+    var macroInfo = fnClone(oVisitor.getSettings()["_macroInfo"] || {});
+    var oTraceMetadataContext = {
+      macro: sName,
+      metaDataContexts: [],
+      properties: {}
+    };
+
+    if (aMetadataContextKeys.length === 0) {
+      //In case the macro has not metadata.js we take all metadataContexts except this
+      aMetadataContextKeys = Object.keys(mContexts).filter(function (name) {
+        return name !== "this";
+      });
+    }
+
+    if (!oNode.getAttribute("xmlns:trace")) {
+      oNode.setAttributeNS(xmlns, "xmlns:trace", traceNamespace);
+    }
+
+    if (aMetadataContextKeys.length > 0) {
+      aMetadataContextKeys.forEach(function (sKey) {
+        var oContext = mContexts[sKey],
+            oMetaDataContext = oContext && {
+          name: sKey,
+          path: oContext.getPath() //data: JSON.stringify(oContext.getObject(),null,2)
+
+        };
+
+        if (oMetaDataContext) {
+          oTraceMetadataContext.metaDataContexts.push(oMetaDataContext);
+        }
+      });
+      aProperties.forEach(function (sKey) {
+        var //oPropertySettings = oMetadata.properties[sKey],
+        oProperty = mContexts.this.getObject(sKey); // (oNode.hasAttribute(sKey) && oNode.getAttribute(sKey)) ||
+        // (oPropertySettings.hasOwnProperty("defaultValue") && oPropertySettings.define) ||
+        // false;
+
+        if (oProperty) {
+          oTraceMetadataContext.properties[sKey] = oProperty;
+        }
+      });
+      oTraceMetadataContext.viewInfo = oVisitor.getViewInfo();
+      oTraceMetadataContext.traceID = aTraceInfo.length;
+      macroInfo.parentMacroID = macroInfo.macroID;
+      macroInfo.macroID = oTraceMetadataContext.traceID;
+      oTraceMetadataContext.macroInfo = macroInfo;
+      oNode.setAttributeNS(traceNamespace, "trace:macroID", oTraceMetadataContext.traceID);
+      aTraceInfo.push(oTraceMetadataContext);
+      return oTraceMetadataContext;
+    }
+  }
+  /**
+   * Returns the globally stored trace information for the macro or
+   * control marked with the given id.
+   *
+   * Returns all trace information if no id is specified
+   *
+   *
+  <pre>Structure for a macro
+  {
+  	macro: '', //name of macro
+  	metaDataContexts: [ //Properties of type sap.ui.model.Context
+  		{
+  			name: '', //context property name / key
+  			path: '', //from oContext.getPath()
+  		}
+  	],
+  	properties: { // Other properties which become part of {this>}
+  		property1: value,
+  		property2: value
+  	}
+  	viewInfo: {
+  		viewInfo: {} // As specified in view or fragement creation
+  	},
+  	traceID: this.index, //ID for this trace information,
+  	macroInfo: {
+  		macroID: index, // traceID of this macro (redundant for macros)
+  		parentMacroID, index // traceID of the parent macro (if it has a parent)
+  	}
+  }
+  Structure for a control
+  {
+  	control: '', //control class
+  	properties: { // Other properties which become part of {this>}
+  		property1: {
+  			originalValue: '', //Value before templating
+  			resolvedValue: '' //Value after templating
+  		}
+  	}
+  	contexts: { //Models and Contexts used during templating
+  		// Model or context name used for this control
+  		modelName1: { // For ODataMetaModel
+  			path1: {
+  				path: '', //absolut path within metamodel
+  				data: '', //data of path unless type Object
+  			}
+  		modelName2: {
+  			// for other model types
+  			{
+  				property1: value,
+  				property2: value
+  			}
+  			// In case binding cannot be resolved -> mark as runtime binding
+  			// This is not always true, e.g. in case the path is metamodelpath
+  			{
+  				"bindingFor": "Runtime"
+  			}
+  		}
+  	},
+  	viewInfo: {
+  		viewInfo: {} // As specified in view or fragement creation
+  	},
+  	macroInfo: {
+  		macroID: index, // traceID of the macro that created this control
+  		parentMacroID, index // traceID of the macro's parent macro
+  	},
+  	traceID: this.index //ID for this trace information
+  }</pre>.
+   *
+   * @function
+   * @name sap.fe.macros.TraceInfo.getTraceInfo
+   * @param {number} id TraceInfo id
+   * @returns {object|Array} Object / Array for TraceInfo
+   * @private
+   * @static
+   */
+
+
+  function getTraceInfo(id) {
+    if (id) {
+      return aTraceInfo[id];
+    }
+
+    var aErrors = aTraceInfo.filter(function (traceInfo) {
+      return traceInfo.error;
+    });
+    return aErrors.length > 0 && aErrors || aTraceInfo;
+  }
+  /**
+   * Returns true if TraceInfo is active.
+   *
+   * @function
+   * @name sap.fe.macros.TraceInfo.isTraceInfoActive
+   * @returns {boolean} `true` when active
+   * @private
+   * @static
+   */
+
+
+  function isTraceInfoActive() {
+    return traceIsOn;
+  }
+  /**
+   * @typedef sap.fe.macros.TraceInfo
+   * TraceInfo for SAP Fiori elements
+   *
+   * Once traces is switched, information about macros and controls
+   * that are processed during xml preprocessing ( @see {@link sap.ui.core.util.XMLPreprocessor})
+   * will be collected within this singleton
+   * @namespace
+   * @private
+   * @global
+   * @experimental This module is only for experimental use! <br/><b>This is only a POC and maybe deleted</b>
+   * @since 1.74.0
+   */
+
+
+  return {
+    isTraceInfoActive: isTraceInfoActive,
+    traceMacroCalls: traceMacroCalls,
+    getTraceInfo: getTraceInfo
+  };
+}, true);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["TraceInfo.ts"],"names":["aTraceInfo","traceNamespace","xmlns","traceIsOn","location","search","indexOf","aNamespaces","oCallbacks","fnClone","oObject","JSON","parse","stringify","collectContextInfo","sValue","oContexts","oVisitor","oNode","aContexts","aPromises","ManagedObject","bindingParser","undefined","e","Array","isArray","filter","oContext","path","parts","forEach","aParts","oModel","model","sSimplePath","oRealContext","split","getContext","push","getResult","then","oResult","getModel","getMetadata","getName","getPath","data","catch","bindingFor","exc","Promise","all","fillAttributes","oResults","oAttributes","sName","result","originalValue","resolvedValue","error","stack","toString","collectInfo","i","attributes","length","oAttribute","nodeName","getAttribute","includes","properties","contexts","resolve","sControlName","bIsControl","test","oTraceMetadataContext","control","namespaceURI","ownerDocument","firstChild","setAttributeNS","bRelevant","Object","keys","assign","viewInfo","getViewInfo","macroInfo","getSettings","traceID","visitAttributes","visitChildNodes","exception","node","XMLSerializer","serializeToString","namespace","XMLPreprocessor","plugIn","bind","traceMacroCalls","oMetadata","mContexts","aMetadataContextKeys","metadataContexts","aProperties","macro","metaDataContexts","name","sKey","oMetaDataContext","oProperty","this","getObject","parentMacroID","macroID","getTraceInfo","id","aErrors","traceInfo","isTraceInfoActive"],"mappings":";AAAA;AACA;AACA;;;;AAAA;AACA,MAAMA,UAAiB,GAAG;AACzB;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AA7D0B,GAA1B;AA+DA,MAAMC,cAAc,GAAG,uDAAvB;AAAA,MACCC,KAAK,GAAG,+BADT;;AAEC;AACD;AACA;AACCC,EAAAA,SAAS,GAAGC,QAAQ,CAACC,MAAT,CAAgBC,OAAhB,CAAwB,4BAAxB,IAAwD,CAAC,CALtE;;AAMC;AACD;AACA;AACCC,EAAAA,WAAW,GAAG,CACb,OADa,EAEb,UAFa,EAGb,gBAHa,EAIb,OAJa,EAKb,cALa,EAMb,yBANa,EAOb,oBAPa,EAQb,YARa,EASb,iBATa,EAUb,kBAVa,EAWb,YAXa,CATf;AAAA,MAsBCC,UAAe,GAAG,EAtBnB;;AAwBA,WAASC,OAAT,CAAiBC,OAAjB,EAA+B;AAC9B,WAAOC,IAAI,CAACC,KAAL,CAAWD,IAAI,CAACE,SAAL,CAAeH,OAAf,CAAX,CAAP;AACA;;AACD,WAASI,kBAAT,CAA4BC,MAA5B,EAAyCC,SAAzC,EAAyDC,QAAzD,EAAwEC,KAAxE,EAAoF;AACnF,QAAIC,SAAJ;AACA,QAAMC,SAAgB,GAAG,EAAzB;;AACA,QAAI;AACHD,MAAAA,SAAS,GAAIE,aAAD,CAAuBC,aAAvB,CAAqCP,MAArC,EAA6CQ,SAA7C,EAAwD,KAAxD,EAA+D,IAA/D,KAAwE,EAApF;AACA,KAFD,CAEE,OAAOC,CAAP,EAAU;AACXL,MAAAA,SAAS,GAAG,EAAZ;AACA;;AACDA,IAAAA,SAAS,GAAGM,KAAK,CAACC,OAAN,CAAcP,SAAd,IAA2BA,SAA3B,GAAuC,CAACA,SAAD,CAAnD;AACAA,IAAAA,SAAS,CACPQ,MADF,CACS,UAAUC,QAAV,EAAyB;AAChC,aAAOA,QAAQ,CAACC,IAAT,IAAiBD,QAAQ,CAACE,KAAjC;AACA,KAHF,EAIEC,OAJF,CAIU,UAAUH,QAAV,EAAyB;AACjC,UAAMI,MAAM,GAAGJ,QAAQ,CAACE,KAAT,IAAkB,CAACF,QAAD,CAAjC;AACAI,MAAAA,MAAM,CACJL,MADF,CACS,UAAUC,QAAV,EAAyB;AAChC,eAAOA,QAAQ,CAACC,IAAhB;AACA,OAHF,EAIEE,OAJF,CAIU,UAAUH,QAAV,EAAyB;AACjC,YAAMK,MAAM,GAAIjB,SAAS,CAACY,QAAQ,CAACM,KAAV,CAAT,GAA4BlB,SAAS,CAACY,QAAQ,CAACM,KAAV,CAAT,IAA6B,EAAzE;AACA,YAAMC,WAAW,GAChBP,QAAQ,CAACC,IAAT,CAAcvB,OAAd,CAAsB,GAAtB,IAA6B,CAA7B,GAAiC,CAACsB,QAAQ,CAACM,KAAT,IAAkBN,QAAQ,CAACM,KAAT,GAAiB,GAApC,IAA2CN,QAAQ,CAACC,IAArF,GAA4FD,QAAQ,CAACC,IADtG;AAEA,YAAIO,YAAJ;AACA,YAAIJ,MAAJ;;AAEA,YAAI,OAAOJ,QAAQ,CAACM,KAAhB,KAA0B,WAA1B,IAAyCC,WAAW,CAAC7B,OAAZ,CAAoB,GAApB,IAA2B,CAAC,CAAzE,EAA4E;AAC3E0B,UAAAA,MAAM,GAAGG,WAAW,CAACE,KAAZ,CAAkB,GAAlB,CAAT;AACAT,UAAAA,QAAQ,CAACM,KAAT,GAAiBF,MAAM,CAAC,CAAD,CAAvB;AACAJ,UAAAA,QAAQ,CAACC,IAAT,GAAgBG,MAAM,CAAC,CAAD,CAAtB;AACA;;AACD,YAAI;AACHI,UAAAA,YAAY,GAAGnB,QAAQ,CAACqB,UAAT,CAAoBH,WAApB,CAAf;AACAf,UAAAA,SAAS,CAACmB,IAAV,CACCtB,QAAQ,CACNuB,SADF,CACY,MAAML,WAAN,GAAoB,GADhC,EACqCjB,KADrC,EAEEuB,IAFF,CAEO,UAAUC,OAAV,EAAwB;AAC7B,gBAAIN,YAAY,CAACO,QAAb,GAAwBC,WAAxB,GAAsCC,OAAtC,OAAoD,6BAAxD,EAAuF;AACtF,kBAAI,CAACH,OAAO,CAACT,MAAb,EAAqB;AACpBA,gBAAAA,MAAM,CAACL,QAAQ,CAACC,IAAV,CAAN,GAAwBa,OAAxB,CADoB,CACa;AACjC,eAFD,MAEO;AACNT,gBAAAA,MAAM,CAACL,QAAQ,CAACC,IAAV,CAAN,GAAwB,kBAAkBa,OAAO,CAACI,OAAR,EAA1C;AACA;AACD,aAND,MAMO;AACNb,cAAAA,MAAM,CAACL,QAAQ,CAACC,IAAV,CAAN,GAAwB;AACvBA,gBAAAA,IAAI,EAAEO,YAAY,CAACU,OAAb,EADiB;AAEvBC,gBAAAA,IAAI,EAAE,OAAOL,OAAP,KAAmB,QAAnB,GAA8B,sCAA9B,GAAuEA;AAFtD,eAAxB;AAIA;AACD,WAfF,EAgBEM,KAhBF,CAgBQ,YAAY;AAClBf,YAAAA,MAAM,CAACL,QAAQ,CAACC,IAAV,CAAN,GAAwB;AACvBoB,cAAAA,UAAU,EAAE;AADW,aAAxB;AAGA,WApBF,CADD;AAuBA,SAzBD,CAyBE,OAAOC,GAAP,EAAY;AACbjB,UAAAA,MAAM,CAACL,QAAQ,CAACC,IAAV,CAAN,GAAwB;AACvBoB,YAAAA,UAAU,EAAE;AADW,WAAxB;AAGA;AACD,OA9CF;AA+CA,KArDF;AAsDA,WAAOE,OAAO,CAACC,GAAR,CAAYhC,SAAZ,CAAP;AACA;;AACD,WAASiC,cAAT,CAAwBC,QAAxB,EAAuCC,WAAvC,EAAyDC,KAAzD,EAAqEzC,MAArE,EAAkF;AACjF,WAAOuC,QAAQ,CACbb,IADK,CACA,UAAUgB,MAAV,EAAuB;AAC5BF,MAAAA,WAAW,CAACC,KAAD,CAAX,GACCzC,MAAM,KAAK0C,MAAX,GACG;AACAC,QAAAA,aAAa,EAAE3C,MADf;AAEA4C,QAAAA,aAAa,EAAEF;AAFf,OADH,GAKG1C,MANJ;AAOA,KATK,EAULiC,KAVK,CAUC,UAAUxB,CAAV,EAAkB;AACxB+B,MAAAA,WAAW,CAACC,KAAD,CAAX,GAAqB;AACpBE,QAAAA,aAAa,EAAE3C,MADK;AAEpB6C,QAAAA,KAAK,EAAGpC,CAAC,CAACqC,KAAF,IAAWrC,CAAC,CAACqC,KAAF,CAAQC,QAAR,EAAZ,IAAmCtC;AAFtB,OAArB;AAIA,KAfK,CAAP;AAgBA;;AACD,WAASuC,WAAT,CAAqB7C,KAArB,EAAiCD,QAAjC,EAAgD;AAC/C,QAAMsC,WAAW,GAAG,EAApB;AACA,QAAMnC,SAAS,GAAG,EAAlB;AACA,QAAMJ,SAAS,GAAG,EAAlB;AACA,QAAIsC,QAAJ;;AACA,SAAK,IAAIU,CAAC,GAAG9C,KAAK,CAAC+C,UAAN,CAAiBC,MAAjB,KAA4B,CAAzC,EAA4CF,CAAC,EAA7C,GAAmD;AAClD,UAAMG,UAAU,GAAGjD,KAAK,CAAC+C,UAAN,CAAiBD,CAAjB,CAAnB;AAAA,UACCR,KAAK,GAAGW,UAAU,CAACC,QADpB;AAAA,UAECrD,MAAM,GAAGG,KAAK,CAACmD,YAAN,CAAmBb,KAAnB,CAFV;;AAGA,UAAI,CAAC,CAAC,cAAD,EAAiBc,QAAjB,CAA0Bd,KAA1B,CAAL,EAAuC;AACtCpC,QAAAA,SAAS,CAACmB,IAAV,CAAezB,kBAAkB,CAACC,MAAD,EAASC,SAAT,EAAoBC,QAApB,EAA8BC,KAA9B,CAAjC;AACAoC,QAAAA,QAAQ,GAAGrC,QAAQ,CAACuB,SAAT,CAAmBzB,MAAnB,EAA2BG,KAA3B,CAAX;;AACA,YAAIoC,QAAJ,EAAc;AACblC,UAAAA,SAAS,CAACmB,IAAV,CAAec,cAAc,CAACC,QAAD,EAAWC,WAAX,EAAwBC,KAAxB,EAA+BzC,MAA/B,CAA7B;AACA,SAFD,MAEO,CACN;AACA;AACD;AACD;;AACD,WAAOoC,OAAO,CAACC,GAAR,CAAYhC,SAAZ,EAAuBqB,IAAvB,CAA4B,YAAY;AAC9C,aAAO;AAAE8B,QAAAA,UAAU,EAAEhB,WAAd;AAA2BiB,QAAAA,QAAQ,EAAExD;AAArC,OAAP;AACA,KAFM,CAAP;AAGA;;AACD,WAASyD,OAAT,CAAiBvD,KAAjB,EAA6BD,QAA7B,EAA4C;AAC3C,QAAMyD,YAAY,GAAGxD,KAAK,CAACkD,QAAN,CAAe/B,KAAf,CAAqB,GAArB,EAA0B,CAA1B,KAAgCnB,KAAK,CAACkD,QAA3D;AAAA,QACCO,UAAU,GAAG,SAASC,IAAT,CAAcF,YAAd,CADd;AAAA,QAECG,qBAA0B,GAAG;AAC5BC,MAAAA,OAAO,EAAE5D,KAAK,CAAC6D,YAAN,GAAqB,GAArB,IAA4B7D,KAAK,CAACkD,QAAN,CAAe/B,KAAf,CAAqB,GAArB,EAA0B,CAA1B,KAAgCnB,KAAK,CAACkD,QAAlE;AADmB,KAF9B;;AAMA,QAAIO,UAAJ,EAAgB;AACf,UAAI,CAACzD,KAAK,CAAC8D,aAAN,CAAoBC,UAApB,CAA+BZ,YAA/B,CAA4C,aAA5C,CAAL,EAAiE;AAChEnD,QAAAA,KAAK,CAAC8D,aAAN,CAAoBC,UAApB,CAA+BC,cAA/B,CAA8ChF,KAA9C,EAAqD,aAArD,EAAoED,cAApE;AACAiB,QAAAA,KAAK,CAAC8D,aAAN,CAAoBC,UAApB,CAA+BC,cAA/B,CAA8CjF,cAA9C,EAA8D,UAA9D,EAA0E,IAA1E;AACA;;AACD,aAAO8D,WAAW,CAAC7C,KAAD,EAAQD,QAAR,CAAX,CACLwB,IADK,CACA,UAAUgB,MAAV,EAAoD;AACzD,YAAM0B,SAAS,GAAGC,MAAM,CAACC,IAAP,CAAY5B,MAAM,CAACe,QAAnB,EAA6BN,MAA7B,GAAsC,CAAxD,CADyD,CACE;;AAC3D,YAAIiB,SAAJ,EAAe;AACdC,UAAAA,MAAM,CAACE,MAAP,CAAcT,qBAAd,EAAqCpB,MAArC;AACAoB,UAAAA,qBAAqB,CAACU,QAAtB,GAAiCtE,QAAQ,CAACuE,WAAT,EAAjC;AACAX,UAAAA,qBAAqB,CAACY,SAAtB,GAAkCxE,QAAQ,CAACyE,WAAT,GAAuB,YAAvB,CAAlC;AACAb,UAAAA,qBAAqB,CAACc,OAAtB,GAAgC3F,UAAU,CAACkE,MAA3C;AACAhD,UAAAA,KAAK,CAACgE,cAAN,CAAqBjF,cAArB,EAAqC,eAArC,EAAsD4E,qBAAqB,CAACc,OAA5E;AACA3F,UAAAA,UAAU,CAACuC,IAAX,CAAgBsC,qBAAhB;AACA;;AACD,eAAO5D,QAAQ,CAAC2E,eAAT,CAAyB1E,KAAzB,EAAgCuB,IAAhC,CAAqC,YAAY;AACvD,iBAAOxB,QAAQ,CAAC4E,eAAT,CAAyB3E,KAAzB,CAAP;AACA,SAFM,CAAP;AAGA,OAdK,EAeL8B,KAfK,CAeC,UAAUE,GAAV,EAAoB;AAC1B2B,QAAAA,qBAAqB,CAACjB,KAAtB,GAA8B;AAC7BkC,UAAAA,SAAS,EAAE5C,GADkB;AAE7B6C,UAAAA,IAAI,EAAE,IAAIC,aAAJ,GAAoBC,iBAApB,CAAsC/E,KAAtC;AAFuB,SAA9B;AAIA,OApBK,CAAP;AAqBA,KA1BD,MA0BO;AACN,aAAOD,QAAQ,CAAC2E,eAAT,CAAyB1E,KAAzB,EAAgCuB,IAAhC,CAAqC,YAAY;AACvD,eAAOxB,QAAQ,CAAC4E,eAAT,CAAyB3E,KAAzB,CAAP;AACA,OAFM,CAAP;AAGA;AACD;AACD;AACA;AACA;AACA;;;AACA,MAAIf,SAAJ,EAAe;AACdI,IAAAA,WAAW,CAACwB,OAAZ,CAAoB,UAAUmE,SAAV,EAA6B;AAChD1F,MAAAA,UAAU,CAAC0F,SAAD,CAAV,GAAwBC,eAAe,CAACC,MAAhB,CAAuB3B,OAAO,CAAC4B,IAAR,CAAaH,SAAb,CAAvB,EAAgDA,SAAhD,CAAxB;AACA,KAFD;AAGA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,WAASI,eAAT,CAAyB9C,KAAzB,EAAwC+C,SAAxC,EAAwDC,SAAxD,EAAwEtF,KAAxE,EAAoFD,QAApF,EAAmG;AAClG,QAAIwF,oBAAoB,GAAIF,SAAS,CAACG,gBAAV,IAA8BtB,MAAM,CAACC,IAAP,CAAYkB,SAAS,CAACG,gBAAtB,CAA/B,IAA2E,EAAtG;AACA,QAAMC,WAAW,GAAIJ,SAAS,CAAChC,UAAV,IAAwBa,MAAM,CAACC,IAAP,CAAYkB,SAAS,CAAChC,UAAtB,CAAzB,IAA+D,EAAnF;AACA,QAAMkB,SAAS,GAAGhF,OAAO,CAACQ,QAAQ,CAACyE,WAAT,GAAuB,YAAvB,KAAwC,EAAzC,CAAzB;AACA,QAAMb,qBAA0B,GAAG;AAClC+B,MAAAA,KAAK,EAAEpD,KAD2B;AAElCqD,MAAAA,gBAAgB,EAAE,EAFgB;AAGlCtC,MAAAA,UAAU,EAAE;AAHsB,KAAnC;;AAMA,QAAIkC,oBAAoB,CAACvC,MAArB,KAAgC,CAApC,EAAuC;AACtC;AACAuC,MAAAA,oBAAoB,GAAGrB,MAAM,CAACC,IAAP,CAAYmB,SAAZ,EAAuB7E,MAAvB,CAA8B,UAAUmF,IAAV,EAAwB;AAC5E,eAAOA,IAAI,KAAK,MAAhB;AACA,OAFsB,CAAvB;AAGA;;AAED,QAAI,CAAC5F,KAAK,CAACmD,YAAN,CAAmB,aAAnB,CAAL,EAAwC;AACvCnD,MAAAA,KAAK,CAACgE,cAAN,CAAqBhF,KAArB,EAA4B,aAA5B,EAA2CD,cAA3C;AACA;;AAED,QAAIwG,oBAAoB,CAACvC,MAArB,GAA8B,CAAlC,EAAqC;AACpCuC,MAAAA,oBAAoB,CAAC1E,OAArB,CAA6B,UAAUgF,IAAV,EAAqB;AACjD,YAAMnF,QAAQ,GAAG4E,SAAS,CAACO,IAAD,CAA1B;AAAA,YACCC,gBAAqB,GAAGpF,QAAQ,IAAI;AACnCkF,UAAAA,IAAI,EAAEC,IAD6B;AAEnClF,UAAAA,IAAI,EAAED,QAAQ,CAACkB,OAAT,EAF6B,CAGnC;;AAHmC,SADrC;;AAOA,YAAIkE,gBAAJ,EAAsB;AACrBnC,UAAAA,qBAAqB,CAACgC,gBAAtB,CAAuCtE,IAAvC,CAA4CyE,gBAA5C;AACA;AACD,OAXD;AAaAL,MAAAA,WAAW,CAAC5E,OAAZ,CAAoB,UAAUgF,IAAV,EAAqB;AACxC,YAAM;AACLE,QAAAA,SAAS,GAAGT,SAAS,CAACU,IAAV,CAAeC,SAAf,CAAyBJ,IAAzB,CADb,CADwC,CAGxC;AACA;AACA;;AAEA,YAAIE,SAAJ,EAAe;AACdpC,UAAAA,qBAAqB,CAACN,UAAtB,CAAiCwC,IAAjC,IAAyCE,SAAzC;AACA;AACD,OAVD;AAWApC,MAAAA,qBAAqB,CAACU,QAAtB,GAAiCtE,QAAQ,CAACuE,WAAT,EAAjC;AACAX,MAAAA,qBAAqB,CAACc,OAAtB,GAAgC3F,UAAU,CAACkE,MAA3C;AACAuB,MAAAA,SAAS,CAAC2B,aAAV,GAA0B3B,SAAS,CAAC4B,OAApC;AACA5B,MAAAA,SAAS,CAAC4B,OAAV,GAAoBxC,qBAAqB,CAACc,OAA1C;AACAd,MAAAA,qBAAqB,CAACY,SAAtB,GAAkCA,SAAlC;AACAvE,MAAAA,KAAK,CAACgE,cAAN,CAAqBjF,cAArB,EAAqC,eAArC,EAAsD4E,qBAAqB,CAACc,OAA5E;AACA3F,MAAAA,UAAU,CAACuC,IAAX,CAAgBsC,qBAAhB;AACA,aAAOA,qBAAP;AACA;AACD;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,WAASyC,YAAT,CAAsBC,EAAtB,EAAkC;AACjC,QAAIA,EAAJ,EAAQ;AACP,aAAOvH,UAAU,CAACuH,EAAD,CAAjB;AACA;;AACD,QAAMC,OAAO,GAAGxH,UAAU,CAAC2B,MAAX,CAAkB,UAAU8F,SAAV,EAA0B;AAC3D,aAAOA,SAAS,CAAC7D,KAAjB;AACA,KAFe,CAAhB;AAGA,WAAQ4D,OAAO,CAACtD,MAAR,GAAiB,CAAjB,IAAsBsD,OAAvB,IAAmCxH,UAA1C;AACA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,WAAS0H,iBAAT,GAA6B;AAC5B,WAAOvH,SAAP;AACA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;SACe;AACduH,IAAAA,iBAAiB,EAAEA,iBADL;AAEdpB,IAAAA,eAAe,EAAEA,eAFH;AAGdgB,IAAAA,YAAY,EAAEA;AAHA,G","sourceRoot":".","sourcesContent":["import ManagedObject from \"sap/ui/base/ManagedObject\";\nimport XMLPreprocessor from \"sap/ui/core/util/XMLPreprocessor\";\n//Trace information\nconst aTraceInfo: any[] = [\n\t/* Structure for a macro\n\t\t\t{\n\t\t\t\tmacro: '', //name of macro\n\t\t\t\tmetaDataContexts: [ //Properties of type sap.ui.model.Context\n\t\t\t\t\t{\n\t\t\t\t\t\tname: '', //context property name / key\n\t\t\t\t\t\tpath: '', //from oContext.getPath()\n\t\t\t\t\t}\n\t\t\t\t],\n\t\t\t\tproperties: { // Other properties which become part of {this>}\n\t\t\t\t\tproperty1: value,\n\t\t\t\t\tproperty2: value\n\t\t\t\t}\n\t\t\t\tviewInfo: {\n\t\t\t\t\tviewInfo: {} // As specified in view or fragement creation\n\t\t\t\t},\n\t\t\t\ttraceID: this.index, //ID for this trace information,\n\t\t\t\tmacroInfo: {\n\t\t\t\t\tmacroID: index, // traceID of this macro (redundant for macros)\n\t\t\t\t\tparentMacroID, index // traceID of the parent macro (if it has a parent)\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Structure for a control\n\t\t\t{\n\t\t\t\tcontrol: '', //control class\n\t\t\t\tproperties: { // Other properties which become part of {this>}\n\t\t\t\t\tproperty1: {\n\t\t\t\t\t\toriginalValue: '', //Value before templating\n\t\t\t\t\t\tresolvedValue: '' //Value after templating\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tcontexts: { //Models and Contexts used during templating\n\t\t\t\t\t// Model or context name used for this control\n\t\t\t\t\tmodelName1: { // For ODataMetaModel\n\t\t\t\t\t\tpath1: {\n\t\t\t\t\t\t\tpath: '', //absolut path within metamodel\n\t\t\t\t\t\t\tdata: '', //data of path unless type Object\n\t\t\t\t\t\t}\n\t\t\t\t\tmodelName2: {\n\t\t\t\t\t\t// for other model types\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tproperty1: value,\n\t\t\t\t\t\t\tproperty2: value\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// In case binding cannot be resolved -> mark as runtime binding\n\t\t\t\t\t\t// This is not always true, e.g. in case the path is metamodelpath\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\"bindingFor\": \"Runtime\"\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\tviewInfo: {\n\t\t\t\t\tviewInfo: {} // As specified in view or fragement creation\n\t\t\t\t},\n\t\t\t\tmacroInfo: {\n\t\t\t\t\tmacroID: index, // traceID of the macro that created this control\n\t\t\t\t\tparentMacroID, index // traceID of the macro's parent macro\n\t\t\t\t},\n\t\t\t\ttraceID: this.index //ID for this trace information\n\t\t\t}\n\t\t\t*/\n];\nconst traceNamespace = \"http://schemas.sap.com/sapui5/extension/sap.fe.info/1\",\n\txmlns = \"http://www.w3.org/2000/xmlns/\",\n\t/**\n\t * Switch is currently based on url parameter\n\t */\n\ttraceIsOn = location.search.indexOf(\"sap-ui-xx-feTraceInfo=true\") > -1,\n\t/**\n\t * Specify all namespaces that shall be traced during templating\n\t */\n\taNamespaces = [\n\t\t\"sap.m\",\n\t\t\"sap.uxap\",\n\t\t\"sap.ui.unified\",\n\t\t\"sap.f\",\n\t\t\"sap.ui.table\",\n\t\t\"sap.suite.ui.microchart\",\n\t\t\"sap.ui.layout.form\",\n\t\t\"sap.ui.mdc\",\n\t\t\"sap.ui.mdc.link\",\n\t\t\"sap.ui.mdc.field\",\n\t\t\"sap.fe.fpm\"\n\t],\n\toCallbacks: any = {};\n\nfunction fnClone(oObject: any) {\n\treturn JSON.parse(JSON.stringify(oObject));\n}\nfunction collectContextInfo(sValue: any, oContexts: any, oVisitor: any, oNode: any) {\n\tlet aContexts;\n\tconst aPromises: any[] = [];\n\ttry {\n\t\taContexts = (ManagedObject as any).bindingParser(sValue, undefined, false, true) || [];\n\t} catch (e) {\n\t\taContexts = [];\n\t}\n\taContexts = Array.isArray(aContexts) ? aContexts : [aContexts];\n\taContexts\n\t\t.filter(function (oContext: any) {\n\t\t\treturn oContext.path || oContext.parts;\n\t\t})\n\t\t.forEach(function (oContext: any) {\n\t\t\tconst aParts = oContext.parts || [oContext];\n\t\t\taParts\n\t\t\t\t.filter(function (oContext: any) {\n\t\t\t\t\treturn oContext.path;\n\t\t\t\t})\n\t\t\t\t.forEach(function (oContext: any) {\n\t\t\t\t\tconst oModel = (oContexts[oContext.model] = oContexts[oContext.model] || {});\n\t\t\t\t\tconst sSimplePath =\n\t\t\t\t\t\toContext.path.indexOf(\">\") < 0 ? (oContext.model && oContext.model + \">\") + oContext.path : oContext.path;\n\t\t\t\t\tlet oRealContext: any;\n\t\t\t\t\tlet aParts;\n\n\t\t\t\t\tif (typeof oContext.model === \"undefined\" && sSimplePath.indexOf(\">\") > -1) {\n\t\t\t\t\t\taParts = sSimplePath.split(\">\");\n\t\t\t\t\t\toContext.model = aParts[0];\n\t\t\t\t\t\toContext.path = aParts[1];\n\t\t\t\t\t}\n\t\t\t\t\ttry {\n\t\t\t\t\t\toRealContext = oVisitor.getContext(sSimplePath);\n\t\t\t\t\t\taPromises.push(\n\t\t\t\t\t\t\toVisitor\n\t\t\t\t\t\t\t\t.getResult(\"{\" + sSimplePath + \"}\", oNode)\n\t\t\t\t\t\t\t\t.then(function (oResult: any) {\n\t\t\t\t\t\t\t\t\tif (oRealContext.getModel().getMetadata().getName() === \"sap.ui.model.json.JSONModel\") {\n\t\t\t\t\t\t\t\t\t\tif (!oResult.oModel) {\n\t\t\t\t\t\t\t\t\t\t\toModel[oContext.path] = oResult; //oRealContext.getObject(oContext.path);\n\t\t\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\t\t\toModel[oContext.path] = \"Context from \" + oResult.getPath();\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\t\toModel[oContext.path] = {\n\t\t\t\t\t\t\t\t\t\t\tpath: oRealContext.getPath(),\n\t\t\t\t\t\t\t\t\t\t\tdata: typeof oResult === \"object\" ? \"[ctrl/cmd-click] on path to see data\" : oResult\n\t\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t\t.catch(function () {\n\t\t\t\t\t\t\t\t\toModel[oContext.path] = {\n\t\t\t\t\t\t\t\t\t\tbindingFor: \"Runtime\"\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t})\n\t\t\t\t\t\t);\n\t\t\t\t\t} catch (exc) {\n\t\t\t\t\t\toModel[oContext.path] = {\n\t\t\t\t\t\t\tbindingFor: \"Runtime\"\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t});\n\treturn Promise.all(aPromises);\n}\nfunction fillAttributes(oResults: any, oAttributes: any, sName: any, sValue: any) {\n\treturn oResults\n\t\t.then(function (result: any) {\n\t\t\toAttributes[sName] =\n\t\t\t\tsValue !== result\n\t\t\t\t\t? {\n\t\t\t\t\t\t\toriginalValue: sValue,\n\t\t\t\t\t\t\tresolvedValue: result\n\t\t\t\t\t  }\n\t\t\t\t\t: sValue;\n\t\t})\n\t\t.catch(function (e: any) {\n\t\t\toAttributes[sName] = {\n\t\t\t\toriginalValue: sValue,\n\t\t\t\terror: (e.stack && e.stack.toString()) || e\n\t\t\t};\n\t\t});\n}\nfunction collectInfo(oNode: any, oVisitor: any) {\n\tconst oAttributes = {};\n\tconst aPromises = [];\n\tconst oContexts = {};\n\tlet oResults;\n\tfor (let i = oNode.attributes.length >>> 0; i--; ) {\n\t\tconst oAttribute = oNode.attributes[i],\n\t\t\tsName = oAttribute.nodeName,\n\t\t\tsValue = oNode.getAttribute(sName);\n\t\tif (![\"core:require\"].includes(sName)) {\n\t\t\taPromises.push(collectContextInfo(sValue, oContexts, oVisitor, oNode));\n\t\t\toResults = oVisitor.getResult(sValue, oNode);\n\t\t\tif (oResults) {\n\t\t\t\taPromises.push(fillAttributes(oResults, oAttributes, sName, sValue));\n\t\t\t} else {\n\t\t\t\t//What\n\t\t\t}\n\t\t}\n\t}\n\treturn Promise.all(aPromises).then(function () {\n\t\treturn { properties: oAttributes, contexts: oContexts };\n\t});\n}\nfunction resolve(oNode: any, oVisitor: any) {\n\tconst sControlName = oNode.nodeName.split(\":\")[1] || oNode.nodeName,\n\t\tbIsControl = /^[A-Z]/.test(sControlName),\n\t\toTraceMetadataContext: any = {\n\t\t\tcontrol: oNode.namespaceURI + \".\" + (oNode.nodeName.split(\":\")[1] || oNode.nodeName)\n\t\t};\n\n\tif (bIsControl) {\n\t\tif (!oNode.ownerDocument.firstChild.getAttribute(\"xmlns:trace\")) {\n\t\t\toNode.ownerDocument.firstChild.setAttributeNS(xmlns, \"xmlns:trace\", traceNamespace);\n\t\t\toNode.ownerDocument.firstChild.setAttributeNS(traceNamespace, \"trace:is\", \"on\");\n\t\t}\n\t\treturn collectInfo(oNode, oVisitor)\n\t\t\t.then(function (result: { properties: {}; contexts: {} }) {\n\t\t\t\tconst bRelevant = Object.keys(result.contexts).length > 0; //If no context was used it is not relevant so we ignore Object.keys(result.properties).length\n\t\t\t\tif (bRelevant) {\n\t\t\t\t\tObject.assign(oTraceMetadataContext, result);\n\t\t\t\t\toTraceMetadataContext.viewInfo = oVisitor.getViewInfo();\n\t\t\t\t\toTraceMetadataContext.macroInfo = oVisitor.getSettings()[\"_macroInfo\"];\n\t\t\t\t\toTraceMetadataContext.traceID = aTraceInfo.length;\n\t\t\t\t\toNode.setAttributeNS(traceNamespace, \"trace:traceID\", oTraceMetadataContext.traceID);\n\t\t\t\t\taTraceInfo.push(oTraceMetadataContext);\n\t\t\t\t}\n\t\t\t\treturn oVisitor.visitAttributes(oNode).then(function () {\n\t\t\t\t\treturn oVisitor.visitChildNodes(oNode);\n\t\t\t\t});\n\t\t\t})\n\t\t\t.catch(function (exc: any) {\n\t\t\t\toTraceMetadataContext.error = {\n\t\t\t\t\texception: exc,\n\t\t\t\t\tnode: new XMLSerializer().serializeToString(oNode)\n\t\t\t\t};\n\t\t\t});\n\t} else {\n\t\treturn oVisitor.visitAttributes(oNode).then(function () {\n\t\t\treturn oVisitor.visitChildNodes(oNode);\n\t\t});\n\t}\n}\n/**\n * Register path-through XMLPreprocessor plugin for all namespaces\n * given above in aNamespaces\n */\nif (traceIsOn) {\n\taNamespaces.forEach(function (namespace: string) {\n\t\toCallbacks[namespace] = XMLPreprocessor.plugIn(resolve.bind(namespace), namespace);\n\t});\n}\n/**\n * Adds information about the processing of one macro to the collection.\n *\n * @name sap.fe.macros.TraceInfo.traceMacroCalls\n * @param {string} sName Macro class name\n * @param {object} oMetadata Definition from (macro).metadata.js\n * @param {object} mContexts Available named contexts\n * @param {XMLNode} oNode\n * @param {object} oVisitor\n * @returns {object}\n * @private\n * @ui5-restricted\n * @static\n */\nfunction traceMacroCalls(sName: string, oMetadata: any, mContexts: any, oNode: any, oVisitor: any) {\n\tlet aMetadataContextKeys = (oMetadata.metadataContexts && Object.keys(oMetadata.metadataContexts)) || [];\n\tconst aProperties = (oMetadata.properties && Object.keys(oMetadata.properties)) || [];\n\tconst macroInfo = fnClone(oVisitor.getSettings()[\"_macroInfo\"] || {});\n\tconst oTraceMetadataContext: any = {\n\t\tmacro: sName,\n\t\tmetaDataContexts: [] as any[],\n\t\tproperties: {}\n\t};\n\n\tif (aMetadataContextKeys.length === 0) {\n\t\t//In case the macro has not metadata.js we take all metadataContexts except this\n\t\taMetadataContextKeys = Object.keys(mContexts).filter(function (name: string) {\n\t\t\treturn name !== \"this\";\n\t\t});\n\t}\n\n\tif (!oNode.getAttribute(\"xmlns:trace\")) {\n\t\toNode.setAttributeNS(xmlns, \"xmlns:trace\", traceNamespace);\n\t}\n\n\tif (aMetadataContextKeys.length > 0) {\n\t\taMetadataContextKeys.forEach(function (sKey: any) {\n\t\t\tconst oContext = mContexts[sKey],\n\t\t\t\toMetaDataContext: any = oContext && {\n\t\t\t\t\tname: sKey,\n\t\t\t\t\tpath: oContext.getPath()\n\t\t\t\t\t//data: JSON.stringify(oContext.getObject(),null,2)\n\t\t\t\t};\n\n\t\t\tif (oMetaDataContext) {\n\t\t\t\toTraceMetadataContext.metaDataContexts.push(oMetaDataContext);\n\t\t\t}\n\t\t});\n\n\t\taProperties.forEach(function (sKey: any) {\n\t\t\tconst //oPropertySettings = oMetadata.properties[sKey],\n\t\t\t\toProperty = mContexts.this.getObject(sKey);\n\t\t\t// (oNode.hasAttribute(sKey) && oNode.getAttribute(sKey)) ||\n\t\t\t// (oPropertySettings.hasOwnProperty(\"defaultValue\") && oPropertySettings.define) ||\n\t\t\t// false;\n\n\t\t\tif (oProperty) {\n\t\t\t\toTraceMetadataContext.properties[sKey] = oProperty;\n\t\t\t}\n\t\t});\n\t\toTraceMetadataContext.viewInfo = oVisitor.getViewInfo();\n\t\toTraceMetadataContext.traceID = aTraceInfo.length;\n\t\tmacroInfo.parentMacroID = macroInfo.macroID;\n\t\tmacroInfo.macroID = oTraceMetadataContext.traceID;\n\t\toTraceMetadataContext.macroInfo = macroInfo;\n\t\toNode.setAttributeNS(traceNamespace, \"trace:macroID\", oTraceMetadataContext.traceID);\n\t\taTraceInfo.push(oTraceMetadataContext);\n\t\treturn oTraceMetadataContext;\n\t}\n}\n/**\n * Returns the globally stored trace information for the macro or\n * control marked with the given id.\n *\n * Returns all trace information if no id is specified\n *\n *\n<pre>Structure for a macro\n{\n\tmacro: '', //name of macro\n\tmetaDataContexts: [ //Properties of type sap.ui.model.Context\n\t\t{\n\t\t\tname: '', //context property name / key\n\t\t\tpath: '', //from oContext.getPath()\n\t\t}\n\t],\n\tproperties: { // Other properties which become part of {this>}\n\t\tproperty1: value,\n\t\tproperty2: value\n\t}\n\tviewInfo: {\n\t\tviewInfo: {} // As specified in view or fragement creation\n\t},\n\ttraceID: this.index, //ID for this trace information,\n\tmacroInfo: {\n\t\tmacroID: index, // traceID of this macro (redundant for macros)\n\t\tparentMacroID, index // traceID of the parent macro (if it has a parent)\n\t}\n}\nStructure for a control\n{\n\tcontrol: '', //control class\n\tproperties: { // Other properties which become part of {this>}\n\t\tproperty1: {\n\t\t\toriginalValue: '', //Value before templating\n\t\t\tresolvedValue: '' //Value after templating\n\t\t}\n\t}\n\tcontexts: { //Models and Contexts used during templating\n\t\t// Model or context name used for this control\n\t\tmodelName1: { // For ODataMetaModel\n\t\t\tpath1: {\n\t\t\t\tpath: '', //absolut path within metamodel\n\t\t\t\tdata: '', //data of path unless type Object\n\t\t\t}\n\t\tmodelName2: {\n\t\t\t// for other model types\n\t\t\t{\n\t\t\t\tproperty1: value,\n\t\t\t\tproperty2: value\n\t\t\t}\n\t\t\t// In case binding cannot be resolved -> mark as runtime binding\n\t\t\t// This is not always true, e.g. in case the path is metamodelpath\n\t\t\t{\n\t\t\t\t\"bindingFor\": \"Runtime\"\n\t\t\t}\n\t\t}\n\t},\n\tviewInfo: {\n\t\tviewInfo: {} // As specified in view or fragement creation\n\t},\n\tmacroInfo: {\n\t\tmacroID: index, // traceID of the macro that created this control\n\t\tparentMacroID, index // traceID of the macro's parent macro\n\t},\n\ttraceID: this.index //ID for this trace information\n}</pre>.\n *\n * @function\n * @name sap.fe.macros.TraceInfo.getTraceInfo\n * @param {number} id TraceInfo id\n * @returns {object|Array} Object / Array for TraceInfo\n * @private\n * @static\n */\nfunction getTraceInfo(id: number) {\n\tif (id) {\n\t\treturn aTraceInfo[id];\n\t}\n\tconst aErrors = aTraceInfo.filter(function (traceInfo: any) {\n\t\treturn traceInfo.error;\n\t});\n\treturn (aErrors.length > 0 && aErrors) || aTraceInfo;\n}\n/**\n * Returns true if TraceInfo is active.\n *\n * @function\n * @name sap.fe.macros.TraceInfo.isTraceInfoActive\n * @returns {boolean} `true` when active\n * @private\n * @static\n */\nfunction isTraceInfoActive() {\n\treturn traceIsOn;\n}\n/**\n * @typedef sap.fe.macros.TraceInfo\n * TraceInfo for SAP Fiori elements\n *\n * Once traces is switched, information about macros and controls\n * that are processed during xml preprocessing ( @see {@link sap.ui.core.util.XMLPreprocessor})\n * will be collected within this singleton\n * @namespace\n * @private\n * @global\n * @experimental This module is only for experimental use! <br/><b>This is only a POC and maybe deleted</b>\n * @since 1.74.0\n */\nexport default {\n\tisTraceInfoActive: isTraceInfoActive,\n\ttraceMacroCalls: traceMacroCalls,\n\tgetTraceInfo: getTraceInfo\n};\n"]}