@sapui5/sap.fe.core 1.110.0 → 1.111.0

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

@@ -0,0 +1,410 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2023 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/util/deepClone", "sap/base/util/merge", "sap/base/util/ObjectPath", "sap/fe/core/buildingBlocks/BuildingBlockFragment", "sap/fe/core/buildingBlocks/BuildingBlockRuntime", "sap/fe/core/CommonUtils", "sap/fe/core/helpers/BindingToolkit", "sap/fe/core/helpers/StableIdHelper", "sap/fe/core/helpers/TypeGuards", "sap/fe/core/jsx-runtime/jsx", "sap/ui/base/ManagedObject", "sap/ui/core/Component", "sap/ui/core/util/XMLPreprocessor", "../converters/ConverterContext"], function (deepClone, merge, ObjectPath, BuildingBlockFragment, BuildingBlockRuntime, CommonUtils, BindingToolkit, StableIdHelper, TypeGuards, jsx, ManagedObject, Component, XMLPreprocessor, ConverterContext) {
+  "use strict";
+
+  var _exports = {};
+  var isContext = TypeGuards.isContext;
+  var generate = StableIdHelper.generate;
+  var resolveBindingString = BindingToolkit.resolveBindingString;
+  var isUndefinedExpression = BindingToolkit.isUndefinedExpression;
+  var xml = BuildingBlockRuntime.xml;
+  var registerBuildingBlock = BuildingBlockRuntime.registerBuildingBlock;
+  /**
+   * Base class for Building Block
+   */
+  let BuildingBlockBase = /*#__PURE__*/function () {
+    function BuildingBlockBase(props, _oControlConfig, _oSettings) {
+      this.isPublic = false;
+      this.getConverterContext = function (dataModelObjectPath, contextPath, settings, extraParams) {
+        var _settings$models$view;
+        const appComponent = settings.appComponent;
+        const originalViewData = (_settings$models$view = settings.models.viewData) === null || _settings$models$view === void 0 ? void 0 : _settings$models$view.getData();
+        let viewData = Object.assign({}, originalViewData);
+        delete viewData.resourceBundle;
+        viewData = deepClone(viewData);
+        viewData.controlConfiguration = merge(viewData.controlConfiguration, extraParams || {});
+        return ConverterContext.createConverterContextForMacro(dataModelObjectPath.startingEntitySet.name, settings.models.metaModel, appComponent === null || appComponent === void 0 ? void 0 : appComponent.getDiagnostics(), merge, dataModelObjectPath.contextLocation, viewData);
+      };
+      Object.keys(props).forEach(propName => {
+        this[propName] = props[propName];
+      });
+    }
+    /**
+     * Only used internally
+     *
+     * @private
+     */
+    _exports.BuildingBlockBase = BuildingBlockBase;
+    var _proto = BuildingBlockBase.prototype;
+    /**
+     * Convert the given local element ID to a globally unique ID by prefixing with the Building Block ID.
+     *
+     * @param stringParts
+     * @returns Either the global ID or undefined if the Building Block doesn't have an ID
+     * @private
+     */
+    _proto.createId = function createId() {
+      // If the child instance has an ID property use it otherwise return undefined
+      if (this.id) {
+        for (var _len = arguments.length, stringParts = new Array(_len), _key = 0; _key < _len; _key++) {
+          stringParts[_key] = arguments[_key];
+        }
+        return generate([this.id, ...stringParts]);
+      }
+      return undefined;
+    };
+    /**
+     * Only used internally.
+     *
+     * @returns All the properties defined on the object with their values
+     * @private
+     */
+    _proto.getProperties = function getProperties() {
+      const allProperties = {};
+      for (const oInstanceKey in this) {
+        if (this.hasOwnProperty(oInstanceKey)) {
+          allProperties[oInstanceKey] = this[oInstanceKey];
+        }
+      }
+      return allProperties;
+    };
+    BuildingBlockBase.register = function register() {
+      // To be overriden
+    };
+    BuildingBlockBase.unregister = function unregister() {
+      // To be overriden
+    }
+
+    /**
+     * Add a part of string based on the condition.
+     *
+     * @param condition
+     * @param partToAdd
+     * @returns The part to add if the condition is true, otherwise an empty string
+     * @private
+     */;
+    _proto.addConditionally = function addConditionally(condition, partToAdd) {
+      if (condition) {
+        return partToAdd;
+      } else {
+        return "";
+      }
+    }
+    /**
+     * Add an attribute depending on the current value of the property.
+     * If it's undefined the attribute is not added.
+     *
+     * @param attributeName
+     * @param value
+     * @returns The attribute to add if the value is not undefined, otherwise an empty string
+     * @private
+     */;
+    _proto.attr = function attr(attributeName, value) {
+      if (value !== undefined && !isUndefinedExpression(value)) {
+        return () => xml`${attributeName}="${value}"`;
+      } else {
+        return () => "";
+      }
+    };
+    return BuildingBlockBase;
+  }();
+  /**
+   * Base class for runtime building blocks
+   */
+  _exports.BuildingBlockBase = BuildingBlockBase;
+  const ensureMetadata = function (target) {
+    if (!target.hasOwnProperty("metadata")) {
+      target.metadata = deepClone(target.metadata || {
+        properties: {},
+        aggregations: {},
+        events: {},
+        stereotype: "xmlmacro",
+        designtime: ""
+      });
+    }
+    return target.metadata;
+  };
+
+  /**
+   * Decorator for building blocks.
+   *
+   * @param attributeDefinition
+   * @deprecated use `blockAttribute` instead
+   * @returns The decorated property
+   */
+  function xmlAttribute(attributeDefinition) {
+    return function (target, propertyKey, propertyDescriptor) {
+      const metadata = ensureMetadata(target.constructor);
+      if (attributeDefinition.defaultValue === undefined) {
+        var _propertyDescriptor$i;
+        // If there is no defaultValue we can take the value from the initializer (natural way of defining defaults)
+        attributeDefinition.defaultValue = (_propertyDescriptor$i = propertyDescriptor.initializer) === null || _propertyDescriptor$i === void 0 ? void 0 : _propertyDescriptor$i.call(propertyDescriptor);
+      }
+      delete propertyDescriptor.initializer;
+      if (metadata.properties[propertyKey.toString()] === undefined) {
+        metadata.properties[propertyKey.toString()] = attributeDefinition;
+      }
+      return propertyDescriptor;
+    }; // Needed to make TS happy with those decorators;
+  }
+
+  /**
+   * Indicates that the property shall be declared as an xml attribute that can be used from the outside of the building block.
+   *
+   * If defining a runtime Building Block, please make sure to use the correct typings: Depending on its metadata,
+   * a property can either be a {@link sap.ui.model.Context} (<code>type: 'sap.ui.model.Context'</code>),
+   * a constant (<code>bindable: false</code>), or a {@link BindingToolkitExpression} (<code>bindable: true</code>).
+   *
+   * @param attributeDefinition
+   * @returns The decorated property
+   */
+  _exports.xmlAttribute = xmlAttribute;
+  function blockAttribute(attributeDefinition) {
+    return xmlAttribute(attributeDefinition);
+  }
+
+  /**
+   * Decorator for building blocks.
+   *
+   * @deprecated use `blockEvent` instead
+   * @returns The decorated property
+   */
+  _exports.blockAttribute = blockAttribute;
+  function xmlEvent() {
+    return function (target, propertyKey, propertyDescriptor) {
+      const metadata = ensureMetadata(target.constructor);
+      delete propertyDescriptor.initializer;
+      if (metadata.events[propertyKey.toString()] === undefined) {
+        metadata.events[propertyKey.toString()] = {
+          type: "function"
+        };
+      }
+      return propertyDescriptor;
+    }; // Needed to make TS happy with those decorators;
+  }
+  _exports.xmlEvent = xmlEvent;
+  function blockEvent() {
+    return xmlEvent();
+  }
+
+  /**
+   * Decorator for building blocks.
+   *
+   * @param aggregationDefinition
+   * @returns The decorated property
+   * @deprecated use `blockAggregation` instead
+   */
+  _exports.blockEvent = blockEvent;
+  function xmlAggregation(aggregationDefinition) {
+    return function (target, propertyKey, propertyDescriptor) {
+      const metadata = ensureMetadata(target.constructor);
+      delete propertyDescriptor.initializer;
+      if (metadata.aggregations[propertyKey] === undefined) {
+        metadata.aggregations[propertyKey] = aggregationDefinition;
+      }
+      return propertyDescriptor;
+    };
+  }
+  /**
+   * Indicates that the property shall be declared as an xml aggregation that can be used from the outside of the building block.
+   *
+   * @param aggregationDefinition
+   * @returns The decorated property
+   */
+  _exports.xmlAggregation = xmlAggregation;
+  function blockAggregation(aggregationDefinition) {
+    return xmlAggregation(aggregationDefinition);
+  }
+  _exports.blockAggregation = blockAggregation;
+  const RUNTIME_BLOCKS = {};
+  function defineBuildingBlock(oBuildingBlockDefinition) {
+    return function (classDefinition) {
+      const metadata = ensureMetadata(classDefinition);
+      metadata.designtime = oBuildingBlockDefinition.designtime;
+      classDefinition.xmlTag = oBuildingBlockDefinition.name;
+      classDefinition.namespace = oBuildingBlockDefinition.namespace;
+      classDefinition.publicNamespace = oBuildingBlockDefinition.publicNamespace;
+      classDefinition.fragment = oBuildingBlockDefinition.fragment;
+      classDefinition.isOpen = oBuildingBlockDefinition.isOpen;
+      classDefinition.isRuntime = oBuildingBlockDefinition.isRuntime;
+      classDefinition.apiVersion = 2;
+      if (classDefinition.isRuntime === true) {
+        classDefinition.prototype.getTemplate = function (oNode) {
+          const className = `${oBuildingBlockDefinition.namespace}.${oBuildingBlockDefinition.name}`;
+          const extraProps = [];
+          // Function are defined as string but need to be resolved by UI5, as such we store them in an `event` property and will redispatch them later
+          const functionHolderDefinition = [];
+          const propertiesAssignedToFunction = [];
+          const functionStringInOrder = [];
+          for (const propertiesKey in metadata.properties) {
+            let propertyValue = this[propertiesKey];
+            if (propertyValue !== undefined && propertyValue !== null) {
+              if (isContext(propertyValue)) {
+                propertyValue = propertyValue.getPath();
+              }
+              if (metadata.properties[propertiesKey].type === "function") {
+                functionHolderDefinition.push(propertyValue);
+                functionStringInOrder.push(propertyValue);
+                propertiesAssignedToFunction.push(propertiesKey);
+              } else {
+                extraProps.push(xml`feBB:${propertiesKey}="${propertyValue}"`);
+              }
+            }
+          }
+          if (functionHolderDefinition.length > 0) {
+            extraProps.push(xml`functionHolder="${functionHolderDefinition.join(";")}"`);
+            extraProps.push(xml`feBB:functionStringInOrder="${functionStringInOrder.join(",")}"`);
+            extraProps.push(xml`feBB:propertiesAssignedToFunction="${propertiesAssignedToFunction.join(",")}"`);
+          }
+          for (const eventsKey in metadata.events) {
+            const eventsValue = this[eventsKey];
+            if (eventsValue !== undefined) {
+              extraProps.push(xml`feBB:${eventsKey}="${eventsValue}"`);
+            }
+          }
+          // core:require need to be defined on the node itself to be picked up due to the templating step
+          const coreRequire = oNode.getAttribute("core:require") || undefined;
+          if (coreRequire) {
+            extraProps.push(xml`core:require="${coreRequire}"`);
+          }
+          return xml`<feBB:BuildingBlockFragment
+					xmlns:core="sap.ui.core"
+					xmlns:feBB="sap.fe.core.buildingBlocks"
+					fragmentName="${className}"
+
+					id="{this>id}"
+					type="FE_COMPONENTS"
+					${extraProps}
+				>
+				</feBB:BuildingBlockFragment>`;
+        };
+      }
+      classDefinition.register = function () {
+        registerBuildingBlock(classDefinition);
+        if (classDefinition.isRuntime === true) {
+          RUNTIME_BLOCKS[`${oBuildingBlockDefinition.namespace}.${oBuildingBlockDefinition.name}`] = classDefinition;
+        }
+      };
+      classDefinition.unregister = function () {
+        XMLPreprocessor.plugIn(null, classDefinition.namespace, classDefinition.name);
+        XMLPreprocessor.plugIn(null, classDefinition.publicNamespace, classDefinition.name);
+      };
+    };
+  }
+  _exports.defineBuildingBlock = defineBuildingBlock;
+  BuildingBlockFragment.registerType("FE_COMPONENTS", {
+    load: async function (mSettings) {
+      return Promise.resolve(RUNTIME_BLOCKS[mSettings.fragmentName]);
+    },
+    init: function (mSettings) {
+      var _mSettings$customData, _mSettings$customData2, _mSettings$customData3, _mSettings$customData4, _mSettings$containing, _mSettings$containing2, _feCustomData$functio, _feCustomData$propert;
+      let MyClass = mSettings.fragmentContent;
+      if (!MyClass) {
+        // In some case we might have been called here synchronously (unstash case for instance), which means we didn't go through the load function
+        MyClass = RUNTIME_BLOCKS[mSettings.fragmentName];
+      }
+      const classSettings = {};
+      const feCustomData = (mSettings === null || mSettings === void 0 ? void 0 : (_mSettings$customData = mSettings.customData) === null || _mSettings$customData === void 0 ? void 0 : (_mSettings$customData2 = _mSettings$customData[0]) === null || _mSettings$customData2 === void 0 ? void 0 : (_mSettings$customData3 = _mSettings$customData2.mProperties) === null || _mSettings$customData3 === void 0 ? void 0 : (_mSettings$customData4 = _mSettings$customData3.value) === null || _mSettings$customData4 === void 0 ? void 0 : _mSettings$customData4["sap.fe.core.buildingBlocks"]) || {};
+      delete mSettings.customData;
+      const functionHolder = mSettings.functionHolder ?? [];
+      delete mSettings.functionHolder;
+
+      // containingView can also be a fragment, so we have to use the controller to be sure to get the actual view
+      const containingView = ((_mSettings$containing = (_mSettings$containing2 = mSettings.containingView).getController) === null || _mSettings$containing === void 0 ? void 0 : _mSettings$containing.call(_mSettings$containing2).getView()) ?? mSettings.containingView;
+      const pageComponent = Component.getOwnerComponentFor(containingView);
+      const appComponent = CommonUtils.getAppComponent(containingView);
+      const metaModel = appComponent.getMetaModel();
+      const pageModel = pageComponent.getModel("_pageModel");
+      const functionStringInOrder = (_feCustomData$functio = feCustomData.functionStringInOrder) === null || _feCustomData$functio === void 0 ? void 0 : _feCustomData$functio.split(",");
+      const propertiesAssignedToFunction = (_feCustomData$propert = feCustomData.propertiesAssignedToFunction) === null || _feCustomData$propert === void 0 ? void 0 : _feCustomData$propert.split(",");
+      for (const propertyName in MyClass.metadata.properties) {
+        const propertyMetadata = MyClass.metadata.properties[propertyName];
+        const pageModelContext = pageModel.createBindingContext(feCustomData[propertyName]);
+        if (pageModelContext === null) {
+          // value cannot be resolved, so it is either a runtime binding or a constant
+          let value = feCustomData[propertyName];
+          if (typeof value === "string") {
+            if (propertyMetadata.bindable !== true) {
+              // runtime bindings are not allowed, so convert strings into actual primitive types
+              switch (propertyMetadata.type) {
+                case "boolean":
+                  value = value === "true";
+                  break;
+                case "number":
+                  value = Number(value);
+                  break;
+              }
+            } else {
+              // runtime bindings are allowed, so resolve the values as BindingToolkit expressions
+              value = resolveBindingString(value, propertyMetadata.type);
+            }
+          } else if (propertyMetadata.type === "function") {
+            const functionIndex = propertiesAssignedToFunction.indexOf(propertyName);
+            const functionString = functionStringInOrder[functionIndex];
+            const targetFunction = functionHolder === null || functionHolder === void 0 ? void 0 : functionHolder.find(functionDef => {
+              var _functionDef$;
+              return ((_functionDef$ = functionDef[0]) === null || _functionDef$ === void 0 ? void 0 : _functionDef$._sapui_handlerName) === functionString;
+            });
+            // We use the _sapui_handlerName to identify which function is the one we want to bind here
+            if (targetFunction && targetFunction.length > 1) {
+              value = targetFunction[0].bind(targetFunction[1]);
+            }
+          }
+          classSettings[propertyName] = value;
+        } else if (pageModelContext.getObject() !== undefined) {
+          // get value from page model
+          classSettings[propertyName] = pageModelContext.getObject();
+        } else {
+          // bind to metamodel
+          classSettings[propertyName] = metaModel.createBindingContext(feCustomData[propertyName]);
+        }
+      }
+      for (const eventName in MyClass.metadata.events) {
+        if (feCustomData[eventName] !== undefined && feCustomData[eventName].startsWith(".")) {
+          classSettings[eventName] = ObjectPath.get(feCustomData[eventName].substring(1), containingView.getController());
+        } else {
+          classSettings[eventName] = ""; // For now, might need to resolve more stuff
+        }
+      }
+
+      return ManagedObject.runWithPreprocessors(() => {
+        const renderedControl = jsx.withContext({
+          view: containingView,
+          appComponent: appComponent
+        }, () => {
+          return new MyClass(classSettings, {}, {
+            isRuntimeInstantiation: true,
+            isPublic: false,
+            appComponent: appComponent
+          }).getContent(containingView, appComponent);
+        });
+        if (!this._bAsync) {
+          this._aContent = renderedControl;
+        }
+        return renderedControl;
+      }, {
+        id: function (sId) {
+          return containingView.createId(sId);
+        },
+        settings: function (controlSettings) {
+          const allAssociations = this.getMetadata().getAssociations();
+          for (const associationDetailName of Object.keys(allAssociations)) {
+            if (controlSettings[associationDetailName] !== undefined) {
+              // The associated elements are indicated via local IDs; we need to change the references to global ones
+              const associations = Array.isArray(controlSettings[associationDetailName]) ? controlSettings[associationDetailName] : [controlSettings[associationDetailName]];
+
+              // Create global IDs for associations given as strings, not for already resolved ManagedObjects
+              controlSettings[associationDetailName] = associations.map(association => typeof association === "string" ? mSettings.containingView.createId(association) : association);
+            }
+          }
+          return controlSettings;
+        }
+      });
+    }
+  });
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["BuildingBlockBase","props","_oControlConfig","_oSettings","isPublic","getConverterContext","dataModelObjectPath","contextPath","settings","extraParams","appComponent","originalViewData","models","viewData","getData","Object","assign","resourceBundle","deepClone","controlConfiguration","merge","ConverterContext","createConverterContextForMacro","startingEntitySet","name","metaModel","getDiagnostics","contextLocation","keys","forEach","propName","createId","id","stringParts","generate","undefined","getProperties","allProperties","oInstanceKey","hasOwnProperty","register","unregister","addConditionally","condition","partToAdd","attr","attributeName","value","isUndefinedExpression","xml","ensureMetadata","target","metadata","properties","aggregations","events","stereotype","designtime","xmlAttribute","attributeDefinition","propertyKey","propertyDescriptor","constructor","defaultValue","initializer","toString","blockAttribute","xmlEvent","type","blockEvent","xmlAggregation","aggregationDefinition","blockAggregation","RUNTIME_BLOCKS","defineBuildingBlock","oBuildingBlockDefinition","classDefinition","xmlTag","namespace","publicNamespace","fragment","isOpen","isRuntime","apiVersion","prototype","getTemplate","oNode","className","extraProps","functionHolderDefinition","propertiesAssignedToFunction","functionStringInOrder","propertiesKey","propertyValue","isContext","getPath","push","length","join","eventsKey","eventsValue","coreRequire","getAttribute","registerBuildingBlock","XMLPreprocessor","plugIn","BuildingBlockFragment","registerType","load","mSettings","Promise","resolve","fragmentName","init","MyClass","fragmentContent","classSettings","feCustomData","customData","mProperties","functionHolder","containingView","getController","getView","pageComponent","Component","getOwnerComponentFor","CommonUtils","getAppComponent","getMetaModel","pageModel","getModel","split","propertyName","propertyMetadata","pageModelContext","createBindingContext","bindable","Number","resolveBindingString","functionIndex","indexOf","functionString","targetFunction","find","functionDef","_sapui_handlerName","bind","getObject","eventName","startsWith","ObjectPath","get","substring","ManagedObject","runWithPreprocessors","renderedControl","jsx","withContext","view","isRuntimeInstantiation","getContent","_bAsync","_aContent","sId","controlSettings","allAssociations","getMetadata","getAssociations","associationDetailName","associations","Array","isArray","map","association"],"sourceRoot":".","sources":["BuildingBlock.ts"],"sourcesContent":["import deepClone from \"sap/base/util/deepClone\";\nimport merge from \"sap/base/util/merge\";\nimport ObjectPath from \"sap/base/util/ObjectPath\";\nimport type AppComponent from \"sap/fe/core/AppComponent\";\nimport BuildingBlockFragment from \"sap/fe/core/buildingBlocks/BuildingBlockFragment\";\nimport type { TemplateProcessorSettings, XMLProcessorTypeValue } from \"sap/fe/core/buildingBlocks/BuildingBlockRuntime\";\nimport { registerBuildingBlock, xml } from \"sap/fe/core/buildingBlocks/BuildingBlockRuntime\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport type { BindingToolkitExpression } from \"sap/fe/core/helpers/BindingToolkit\";\nimport { isUndefinedExpression, resolveBindingString } from \"sap/fe/core/helpers/BindingToolkit\";\nimport { generate } from \"sap/fe/core/helpers/StableIdHelper\";\nimport { isContext } from \"sap/fe/core/helpers/TypeGuards\";\nimport jsx from \"sap/fe/core/jsx-runtime/jsx\";\nimport type TemplateComponent from \"sap/fe/core/TemplateComponent\";\nimport type { DataModelObjectPath } from \"sap/fe/core/templating/DataModelPathHelper\";\nimport ManagedObject from \"sap/ui/base/ManagedObject\";\nimport Component from \"sap/ui/core/Component\";\nimport type View from \"sap/ui/core/mvc/View\";\nimport XMLPreprocessor from \"sap/ui/core/util/XMLPreprocessor\";\nimport type Control from \"sap/ui/mdc/Control\";\nimport type Context from \"sap/ui/model/Context\";\nimport type { ManagedObjectEx } from \"types/extension_types\";\nimport ConverterContext from \"../converters/ConverterContext\";\n\nexport type ObjectValue2 = string | boolean | number | Context | undefined | object | null;\ntype ObjectValue3<T> = T | Record<string, T> | T[];\nexport type ObjectValue = ObjectValue3<ObjectValue2 | Record<string, ObjectValue2> | ObjectValue2[]>;\n\n// Type for the accessor decorator that we end up with in babel.\ntype AccessorDescriptor<T> = TypedPropertyDescriptor<T> & { initializer?: () => T };\nexport type BuildingBlockExtraSettings = {\n\tisPublic: boolean;\n\tisRuntimeInstantiation?: boolean;\n\tappComponent: AppComponent;\n};\n\n/**\n * Base class for Building Block\n */\nexport class BuildingBlockBase {\n\tprotected isPublic = false;\n\tprotected id!: string;\n\tconstructor(props: Record<string, unknown>, _oControlConfig?: unknown, _oSettings?: BuildingBlockExtraSettings) {\n\t\tObject.keys(props).forEach((propName) => {\n\t\t\tthis[propName as keyof this] = props[propName] as never;\n\t\t});\n\t}\n\t/**\n\t * Only used internally\n\t *\n\t * @private\n\t */\n\tpublic getTemplate?(oNode?: Element): string | Promise<string | undefined> | undefined;\n\n\t/**\n\t * Convert the given local element ID to a globally unique ID by prefixing with the Building Block ID.\n\t *\n\t * @param stringParts\n\t * @returns Either the global ID or undefined if the Building Block doesn't have an ID\n\t * @private\n\t */\n\tprotected createId(...stringParts: string[]) {\n\t\t// If the child instance has an ID property use it otherwise return undefined\n\t\tif (this.id) {\n\t\t\treturn generate([this.id, ...stringParts]);\n\t\t}\n\t\treturn undefined;\n\t}\n\tprotected getConverterContext = function (\n\t\tdataModelObjectPath: DataModelObjectPath,\n\t\tcontextPath: string | undefined,\n\t\tsettings: TemplateProcessorSettings,\n\t\textraParams?: Record<string, unknown>\n\t) {\n\t\tconst appComponent = settings.appComponent;\n\t\tconst originalViewData = settings.models.viewData?.getData();\n\t\tlet viewData = Object.assign({}, originalViewData);\n\t\tdelete viewData.resourceBundle;\n\t\tviewData = deepClone(viewData);\n\t\tviewData.controlConfiguration = merge(viewData.controlConfiguration, extraParams || {});\n\t\treturn ConverterContext.createConverterContextForMacro(\n\t\t\tdataModelObjectPath.startingEntitySet.name,\n\t\t\tsettings.models.metaModel,\n\t\t\tappComponent?.getDiagnostics(),\n\t\t\tmerge,\n\t\t\tdataModelObjectPath.contextLocation,\n\t\t\tviewData\n\t\t);\n\t};\n\n\t/**\n\t * Only used internally.\n\t *\n\t * @returns All the properties defined on the object with their values\n\t * @private\n\t */\n\tpublic getProperties() {\n\t\tconst allProperties: Record<string, ObjectValue> = {};\n\t\tfor (const oInstanceKey in this) {\n\t\t\tif (this.hasOwnProperty(oInstanceKey)) {\n\t\t\t\tallProperties[oInstanceKey] = this[oInstanceKey] as unknown as ObjectValue;\n\t\t\t}\n\t\t}\n\t\treturn allProperties;\n\t}\n\tstatic register() {\n\t\t// To be overriden\n\t}\n\tstatic unregister() {\n\t\t// To be overriden\n\t}\n\n\t/**\n\t * Add a part of string based on the condition.\n\t *\n\t * @param condition\n\t * @param partToAdd\n\t * @returns The part to add if the condition is true, otherwise an empty string\n\t * @private\n\t */\n\tprotected addConditionally(condition: boolean, partToAdd: string): string {\n\t\tif (condition) {\n\t\t\treturn partToAdd;\n\t\t} else {\n\t\t\treturn \"\";\n\t\t}\n\t}\n\t/**\n\t * Add an attribute depending on the current value of the property.\n\t * If it's undefined the attribute is not added.\n\t *\n\t * @param attributeName\n\t * @param value\n\t * @returns The attribute to add if the value is not undefined, otherwise an empty string\n\t * @private\n\t */\n\tprotected attr(attributeName: string, value?: XMLProcessorTypeValue): () => string {\n\t\tif (value !== undefined && !isUndefinedExpression(value)) {\n\t\t\treturn () => xml`${attributeName}=\"${value}\"`;\n\t\t} else {\n\t\t\treturn () => \"\";\n\t\t}\n\t}\n}\n\n/**\n * Base class for runtime building blocks\n */\nexport interface RuntimeBuildingBlock extends BuildingBlockBase {\n\tgetContent(containingView: View, appComponent: AppComponent): Control;\n}\n\nexport type BuildingBlockPropertyDefinition = {\n\ttype: string;\n\tisPublic?: boolean;\n\tdefaultValue?: unknown;\n\t/** This property is only evaluated in the V1 API */\n\tcomputed?: boolean;\n\trequired?: boolean;\n\t/** This property is only considered for runtime building blocks */\n\tbindable?: boolean;\n\t$kind?: string[];\n\t$Type?: string[];\n\t/** Function that allows to validate or transform the given input */\n\tvalidate?: Function;\n};\nexport type BuildingBlockMetadataContextDefinition = {\n\ttype: string;\n\tisPublic?: boolean;\n\trequired?: boolean;\n\t/** This property is only evaluated in the V1 API */\n\tcomputed?: boolean;\n\t$Type?: string[];\n\t$kind?: string[];\n};\nexport type BuildingBlockEvent = {};\nexport type BuildingBlockAggregationDefinition = {\n\tisPublic?: boolean;\n\ttype: string;\n\tslot?: string;\n\tisDefault?: boolean;\n\t/** Defines whether the element is based on an actual node that will be rendered or only on XML that will be interpreted */\n\thasVirtualNode?: boolean;\n\tprocessAggregations?: Function;\n};\ntype CommonBuildingBlockDefinition = {\n\tnamespace: string;\n\tname: string;\n\txmlTag?: string;\n\tfragment?: string;\n\tpublicNamespace?: string;\n\tdesigntime?: string;\n\tisRuntime?: boolean;\n\tisOpen?: boolean;\n};\nexport type BuildingBlockDefinitionV2 = CommonBuildingBlockDefinition &\n\t(new () => BuildingBlockBase) &\n\ttypeof BuildingBlockBase & {\n\t\tapiVersion: 2;\n\t\tgetTemplate?: Function;\n\t\tmetadata: BuildingBlockMetadata;\n\t};\n\nexport type BuildingBlockDefinitionV1 = CommonBuildingBlockDefinition & {\n\tname: string;\n\tapiVersion?: 1;\n\tcreate?: Function;\n\tgetTemplate?: Function;\n\tmetadata: BuildingBlockMetadata;\n};\nexport type BuildingBlockDefinition = BuildingBlockDefinitionV2 | BuildingBlockDefinitionV1;\nexport type BuildingBlockMetadata = {\n\tevents: Record<string, BuildingBlockEvent>;\n\tproperties: Record<string, BuildingBlockPropertyDefinition>;\n\taggregations: Record<string, BuildingBlockAggregationDefinition>;\n\tstereotype?: string;\n\tdesigntime?: string;\n};\n\nconst ensureMetadata = function (target: Partial<BuildingBlockDefinitionV2>): BuildingBlockMetadata {\n\tif (!target.hasOwnProperty(\"metadata\")) {\n\t\ttarget.metadata = deepClone(\n\t\t\ttarget.metadata || {\n\t\t\t\tproperties: {},\n\t\t\t\taggregations: {},\n\t\t\t\tevents: {},\n\t\t\t\tstereotype: \"xmlmacro\",\n\t\t\t\tdesigntime: \"\"\n\t\t\t}\n\t\t);\n\t}\n\treturn target.metadata as BuildingBlockMetadata;\n};\n\n/**\n * Decorator for building blocks.\n *\n * @param attributeDefinition\n * @deprecated use `blockAttribute` instead\n * @returns The decorated property\n */\nexport function xmlAttribute(attributeDefinition: BuildingBlockPropertyDefinition): PropertyDecorator {\n\treturn function (target: BuildingBlockBase, propertyKey: string | Symbol, propertyDescriptor: AccessorDescriptor<unknown>) {\n\t\tconst metadata = ensureMetadata(target.constructor);\n\t\tif (attributeDefinition.defaultValue === undefined) {\n\t\t\t// If there is no defaultValue we can take the value from the initializer (natural way of defining defaults)\n\t\t\tattributeDefinition.defaultValue = propertyDescriptor.initializer?.();\n\t\t}\n\t\tdelete propertyDescriptor.initializer;\n\t\tif (metadata.properties[propertyKey.toString()] === undefined) {\n\t\t\tmetadata.properties[propertyKey.toString()] = attributeDefinition;\n\t\t}\n\n\t\treturn propertyDescriptor;\n\t} as unknown as PropertyDecorator; // Needed to make TS happy with those decorators;\n}\n\n/**\n * Indicates that the property shall be declared as an xml attribute that can be used from the outside of the building block.\n *\n * If defining a runtime Building Block, please make sure to use the correct typings: Depending on its metadata,\n * a property can either be a {@link sap.ui.model.Context} (<code>type: 'sap.ui.model.Context'</code>),\n * a constant (<code>bindable: false</code>), or a {@link BindingToolkitExpression} (<code>bindable: true</code>).\n *\n * @param attributeDefinition\n * @returns The decorated property\n */\nexport function blockAttribute(attributeDefinition: BuildingBlockPropertyDefinition): PropertyDecorator {\n\treturn xmlAttribute(attributeDefinition);\n}\n\n/**\n * Decorator for building blocks.\n *\n * @deprecated use `blockEvent` instead\n * @returns The decorated property\n */\nexport function xmlEvent(): PropertyDecorator {\n\treturn function (target: BuildingBlockBase, propertyKey: string | Symbol, propertyDescriptor: AccessorDescriptor<unknown>) {\n\t\tconst metadata = ensureMetadata(target.constructor);\n\t\tdelete propertyDescriptor.initializer;\n\t\tif (metadata.events[propertyKey.toString()] === undefined) {\n\t\t\tmetadata.events[propertyKey.toString()] = { type: \"function\" };\n\t\t}\n\n\t\treturn propertyDescriptor;\n\t} as unknown as PropertyDecorator; // Needed to make TS happy with those decorators;\n}\nexport function blockEvent(): PropertyDecorator {\n\treturn xmlEvent();\n}\n\n/**\n * Decorator for building blocks.\n *\n * @param aggregationDefinition\n * @returns The decorated property\n * @deprecated use `blockAggregation` instead\n */\nexport function xmlAggregation(aggregationDefinition: BuildingBlockAggregationDefinition): PropertyDecorator {\n\treturn function (target: BuildingBlockBase, propertyKey: string, propertyDescriptor: AccessorDescriptor<unknown>) {\n\t\tconst metadata = ensureMetadata(target.constructor);\n\t\tdelete propertyDescriptor.initializer;\n\t\tif (metadata.aggregations[propertyKey] === undefined) {\n\t\t\tmetadata.aggregations[propertyKey] = aggregationDefinition;\n\t\t}\n\n\t\treturn propertyDescriptor;\n\t} as unknown as PropertyDecorator;\n}\n/**\n * Indicates that the property shall be declared as an xml aggregation that can be used from the outside of the building block.\n *\n * @param aggregationDefinition\n * @returns The decorated property\n */\nexport function blockAggregation(aggregationDefinition: BuildingBlockAggregationDefinition): PropertyDecorator {\n\treturn xmlAggregation(aggregationDefinition);\n}\nconst RUNTIME_BLOCKS: Record<string, RuntimeBuildingBlock & BuildingBlockDefinitionV2> = {};\nexport function defineBuildingBlock(oBuildingBlockDefinition: CommonBuildingBlockDefinition): ClassDecorator {\n\treturn function (classDefinition: Partial<BuildingBlockDefinitionV2>) {\n\t\tconst metadata = ensureMetadata(classDefinition);\n\t\tmetadata.designtime = oBuildingBlockDefinition.designtime;\n\t\tclassDefinition.xmlTag = oBuildingBlockDefinition.name;\n\t\tclassDefinition.namespace = oBuildingBlockDefinition.namespace;\n\t\tclassDefinition.publicNamespace = oBuildingBlockDefinition.publicNamespace;\n\t\tclassDefinition.fragment = oBuildingBlockDefinition.fragment;\n\t\tclassDefinition.isOpen = oBuildingBlockDefinition.isOpen;\n\t\tclassDefinition.isRuntime = oBuildingBlockDefinition.isRuntime;\n\t\tclassDefinition.apiVersion = 2;\n\t\tif (classDefinition.isRuntime === true) {\n\t\t\tclassDefinition.prototype.getTemplate = function (oNode: Element) {\n\t\t\t\tconst className = `${oBuildingBlockDefinition.namespace}.${oBuildingBlockDefinition.name}`;\n\t\t\t\tconst extraProps = [];\n\t\t\t\t// Function are defined as string but need to be resolved by UI5, as such we store them in an `event` property and will redispatch them later\n\t\t\t\tconst functionHolderDefinition = [];\n\t\t\t\tconst propertiesAssignedToFunction = [];\n\t\t\t\tconst functionStringInOrder = [];\n\t\t\t\tfor (const propertiesKey in metadata.properties) {\n\t\t\t\t\tlet propertyValue = this[propertiesKey];\n\t\t\t\t\tif (propertyValue !== undefined && propertyValue !== null) {\n\t\t\t\t\t\tif (isContext(propertyValue)) {\n\t\t\t\t\t\t\tpropertyValue = propertyValue.getPath();\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (metadata.properties[propertiesKey].type === \"function\") {\n\t\t\t\t\t\t\tfunctionHolderDefinition.push(propertyValue);\n\t\t\t\t\t\t\tfunctionStringInOrder.push(propertyValue);\n\t\t\t\t\t\t\tpropertiesAssignedToFunction.push(propertiesKey);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\textraProps.push(xml`feBB:${propertiesKey}=\"${propertyValue as XMLProcessorTypeValue}\"`);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (functionHolderDefinition.length > 0) {\n\t\t\t\t\textraProps.push(xml`functionHolder=\"${functionHolderDefinition.join(\";\")}\"`);\n\t\t\t\t\textraProps.push(xml`feBB:functionStringInOrder=\"${functionStringInOrder.join(\",\")}\"`);\n\t\t\t\t\textraProps.push(xml`feBB:propertiesAssignedToFunction=\"${propertiesAssignedToFunction.join(\",\")}\"`);\n\t\t\t\t}\n\t\t\t\tfor (const eventsKey in metadata.events) {\n\t\t\t\t\tconst eventsValue = this[eventsKey];\n\t\t\t\t\tif (eventsValue !== undefined) {\n\t\t\t\t\t\textraProps.push(xml`feBB:${eventsKey}=\"${eventsValue as XMLProcessorTypeValue}\"`);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// core:require need to be defined on the node itself to be picked up due to the templating step\n\t\t\t\tconst coreRequire = oNode.getAttribute(\"core:require\") || undefined;\n\t\t\t\tif (coreRequire) {\n\t\t\t\t\textraProps.push(xml`core:require=\"${coreRequire}\"`);\n\t\t\t\t}\n\t\t\t\treturn xml`<feBB:BuildingBlockFragment\n\t\t\t\t\txmlns:core=\"sap.ui.core\"\n\t\t\t\t\txmlns:feBB=\"sap.fe.core.buildingBlocks\"\n\t\t\t\t\tfragmentName=\"${className}\"\n\n\t\t\t\t\tid=\"{this>id}\"\n\t\t\t\t\ttype=\"FE_COMPONENTS\"\n\t\t\t\t\t${extraProps}\n\t\t\t\t>\n\t\t\t\t</feBB:BuildingBlockFragment>`;\n\t\t\t};\n\t\t}\n\n\t\tclassDefinition.register = function () {\n\t\t\tregisterBuildingBlock(classDefinition as BuildingBlockDefinitionV2);\n\t\t\tif (classDefinition.isRuntime === true) {\n\t\t\t\tRUNTIME_BLOCKS[`${oBuildingBlockDefinition.namespace}.${oBuildingBlockDefinition.name}`] =\n\t\t\t\t\tclassDefinition as RuntimeBuildingBlock & BuildingBlockDefinitionV2;\n\t\t\t}\n\t\t};\n\t\tclassDefinition.unregister = function () {\n\t\t\tXMLPreprocessor.plugIn(null, classDefinition.namespace, classDefinition.name);\n\t\t\tXMLPreprocessor.plugIn(null, classDefinition.publicNamespace, classDefinition.name);\n\t\t};\n\t};\n}\ntype FragmentCustomData = {\n\tmProperties: {\n\t\tvalue: {\n\t\t\t\"sap.fe.core.buildingBlocks\"?: Record<string, string>;\n\t\t};\n\t};\n};\ntype FEComponentFragmentSettings = {\n\tfragmentName: string;\n\tfragmentContent?: RuntimeBuildingBlock & BuildingBlockDefinitionV2;\n\tcontainingView: View;\n\tcustomData?: FragmentCustomData[];\n\tfunctionHolder?: FunctionWithHandler[][];\n};\n\ntype FunctionWithHandler = Function & {\n\t_sapui_handlerName?: string;\n};\ntype FragmentWithInternals = {\n\t_bAsync: boolean;\n\t_aContent: Control | Control[];\n};\nBuildingBlockFragment.registerType(\"FE_COMPONENTS\", {\n\tload: async function (mSettings: FEComponentFragmentSettings) {\n\t\treturn Promise.resolve(RUNTIME_BLOCKS[mSettings.fragmentName]);\n\t},\n\tinit: function (this: FragmentWithInternals, mSettings: FEComponentFragmentSettings) {\n\t\tlet MyClass = mSettings.fragmentContent;\n\t\tif (!MyClass) {\n\t\t\t// In some case we might have been called here synchronously (unstash case for instance), which means we didn't go through the load function\n\t\t\tMyClass = RUNTIME_BLOCKS[mSettings.fragmentName];\n\t\t}\n\t\tconst classSettings: Record<string, unknown> = {};\n\t\tconst feCustomData: Record<string, string> = mSettings?.customData?.[0]?.mProperties?.value?.[\"sap.fe.core.buildingBlocks\"] || {};\n\t\tdelete mSettings.customData;\n\t\tconst functionHolder: FunctionWithHandler[][] = mSettings.functionHolder ?? [];\n\t\tdelete mSettings.functionHolder;\n\n\t\t// containingView can also be a fragment, so we have to use the controller to be sure to get the actual view\n\t\tconst containingView = mSettings.containingView.getController?.().getView() ?? mSettings.containingView;\n\t\tconst pageComponent = Component.getOwnerComponentFor(containingView) as TemplateComponent;\n\t\tconst appComponent = CommonUtils.getAppComponent(containingView);\n\n\t\tconst metaModel = appComponent.getMetaModel();\n\t\tconst pageModel = pageComponent.getModel(\"_pageModel\");\n\n\t\tconst functionStringInOrder: string[] = feCustomData.functionStringInOrder?.split(\",\");\n\t\tconst propertiesAssignedToFunction: string[] = feCustomData.propertiesAssignedToFunction?.split(\",\");\n\t\tfor (const propertyName in MyClass.metadata.properties) {\n\t\t\tconst propertyMetadata = MyClass.metadata.properties[propertyName];\n\t\t\tconst pageModelContext = pageModel.createBindingContext(feCustomData[propertyName]);\n\n\t\t\tif (pageModelContext === null) {\n\t\t\t\t// value cannot be resolved, so it is either a runtime binding or a constant\n\t\t\t\tlet value: string | boolean | number | BindingToolkitExpression<string | boolean | number> = feCustomData[propertyName];\n\n\t\t\t\tif (typeof value === \"string\") {\n\t\t\t\t\tif (propertyMetadata.bindable !== true) {\n\t\t\t\t\t\t// runtime bindings are not allowed, so convert strings into actual primitive types\n\t\t\t\t\t\tswitch (propertyMetadata.type) {\n\t\t\t\t\t\t\tcase \"boolean\":\n\t\t\t\t\t\t\t\tvalue = value === \"true\";\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\tcase \"number\":\n\t\t\t\t\t\t\t\tvalue = Number(value);\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// runtime bindings are allowed, so resolve the values as BindingToolkit expressions\n\t\t\t\t\t\tvalue = resolveBindingString(value, propertyMetadata.type);\n\t\t\t\t\t}\n\t\t\t\t} else if (propertyMetadata.type === \"function\") {\n\t\t\t\t\tconst functionIndex = propertiesAssignedToFunction.indexOf(propertyName);\n\t\t\t\t\tconst functionString = functionStringInOrder[functionIndex];\n\t\t\t\t\tconst targetFunction = functionHolder?.find((functionDef) => functionDef[0]?._sapui_handlerName === functionString);\n\t\t\t\t\t// We use the _sapui_handlerName to identify which function is the one we want to bind here\n\t\t\t\t\tif (targetFunction && targetFunction.length > 1) {\n\t\t\t\t\t\tvalue = targetFunction[0].bind(targetFunction[1]);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tclassSettings[propertyName] = value;\n\t\t\t} else if (pageModelContext.getObject() !== undefined) {\n\t\t\t\t// get value from page model\n\t\t\t\tclassSettings[propertyName] = pageModelContext.getObject();\n\t\t\t} else {\n\t\t\t\t// bind to metamodel\n\t\t\t\tclassSettings[propertyName] = metaModel.createBindingContext(feCustomData[propertyName]);\n\t\t\t}\n\t\t}\n\t\tfor (const eventName in MyClass.metadata.events) {\n\t\t\tif (feCustomData[eventName] !== undefined && feCustomData[eventName].startsWith(\".\")) {\n\t\t\t\tclassSettings[eventName] = ObjectPath.get(feCustomData[eventName].substring(1), containingView.getController());\n\t\t\t} else {\n\t\t\t\tclassSettings[eventName] = \"\"; // For now, might need to resolve more stuff\n\t\t\t}\n\t\t}\n\t\treturn (ManagedObject as unknown as ManagedObjectEx).runWithPreprocessors(\n\t\t\t() => {\n\t\t\t\tconst renderedControl = jsx.withContext({ view: containingView, appComponent: appComponent }, () => {\n\t\t\t\t\treturn (\n\t\t\t\t\t\tnew MyClass!(\n\t\t\t\t\t\t\tclassSettings,\n\t\t\t\t\t\t\t{},\n\t\t\t\t\t\t\t{ isRuntimeInstantiation: true, isPublic: false, appComponent: appComponent }\n\t\t\t\t\t\t) as RuntimeBuildingBlock\n\t\t\t\t\t).getContent(containingView, appComponent);\n\t\t\t\t});\n\t\t\t\tif (!this._bAsync) {\n\t\t\t\t\tthis._aContent = renderedControl;\n\t\t\t\t}\n\t\t\t\treturn renderedControl;\n\t\t\t},\n\t\t\t{\n\t\t\t\tid: function (sId: string) {\n\t\t\t\t\treturn containingView.createId(sId);\n\t\t\t\t},\n\t\t\t\tsettings: function (controlSettings: Record<string, string | ManagedObject | (string | ManagedObject)[]>) {\n\t\t\t\t\tconst allAssociations = this.getMetadata().getAssociations();\n\t\t\t\t\tfor (const associationDetailName of Object.keys(allAssociations)) {\n\t\t\t\t\t\tif (controlSettings[associationDetailName] !== undefined) {\n\t\t\t\t\t\t\t// The associated elements are indicated via local IDs; we need to change the references to global ones\n\t\t\t\t\t\t\tconst associations = (\n\t\t\t\t\t\t\t\tArray.isArray(controlSettings[associationDetailName])\n\t\t\t\t\t\t\t\t\t? controlSettings[associationDetailName]\n\t\t\t\t\t\t\t\t\t: [controlSettings[associationDetailName]]\n\t\t\t\t\t\t\t) as (string | ManagedObject)[];\n\n\t\t\t\t\t\t\t// Create global IDs for associations given as strings, not for already resolved ManagedObjects\n\t\t\t\t\t\t\tcontrolSettings[associationDetailName] = associations.map((association: string | ManagedObject) =>\n\t\t\t\t\t\t\t\ttypeof association === \"string\" ? mSettings.containingView.createId(association) : association\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn controlSettings;\n\t\t\t\t}\n\t\t\t}\n\t\t);\n\t}\n});\n"],"mappings":"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"}