@sapui5/sap.fe.core 1.111.1 → 1.112.0

package/src/sap/fe/core/ResourceModel-dbg.js

@@ -0,0 +1,71 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2023 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/helpers/ClassSupport", "sap/ui/model/resource/ResourceModel"], function (ClassSupport, UI5ResourceModel) {
+  "use strict";
+
+  var _dec, _class;
+  var defineUI5Class = ClassSupport.defineUI5Class;
+  function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+  let ResourceModel = (_dec = defineUI5Class("sap.fe.core.ResourceModel"), _dec(_class = /*#__PURE__*/function (_UI5ResourceModel) {
+    _inheritsLoose(ResourceModel, _UI5ResourceModel);
+    function ResourceModel() {
+      return _UI5ResourceModel.apply(this, arguments) || this;
+    }
+    var _proto = ResourceModel.prototype;
+    /**
+     * Returns text for a given resource key.
+     *
+     * @param textID ID of the Text
+     * @param parameters Array of parameters that are used to create the text
+     * @param metaPath Entity set name or action name to overload a text
+     * @returns Determined text
+     */
+    _proto.getText = function getText(textID, parameters, metaPath) {
+      let resourceKey = textID;
+      const resourceBundle = this._oResourceBundle;
+      if (metaPath) {
+        const resourceKeyExists = this.checkIfResourceKeyExists(`${resourceKey}|${metaPath}`);
+
+        // if resource key with metapath (i.e. entity set name) for instance specific text overriding is provided by the application
+        // then use the same key otherwise use the Framework key
+        resourceKey = resourceKeyExists ? `${resourceKey}|${metaPath}` : resourceKey;
+      }
+      return (resourceBundle === null || resourceBundle === void 0 ? void 0 : resourceBundle.getText(resourceKey, parameters, true)) || textID;
+    }
+
+    /**
+     * Check if a text exists for a given resource key.
+     *
+     * @param textID ID of the Text
+     * @returns True in case the text exists
+     */;
+    _proto.checkIfResourceKeyExists = function checkIfResourceKeyExists(textID) {
+      // There are console errors logged when making calls to getText for keys that are not defined in the resource bundle
+      // for instance keys which are supposed to be provided by the application, e.g, <key>|<entitySet> to override instance specific text
+      // hence check if text exists (using "hasText") in the resource bundle before calling "getText"
+
+      // "hasText" only checks for the key in the immediate resource bundle and not it's custom bundles
+      // hence we need to do this recurrsively to check if the key exists in any of the bundles the forms the FE resource bundle
+      return this._checkIfResourceKeyExists(textID, this._oResourceBundle.aCustomBundles);
+    };
+    _proto._checkIfResourceKeyExists = function _checkIfResourceKeyExists(textID, bundles) {
+      if (bundles !== null && bundles !== void 0 && bundles.length) {
+        for (let i = bundles.length - 1; i >= 0; i--) {
+          const sValue = bundles[i].hasText(textID);
+          // text found return true
+          if (sValue) {
+            return true;
+          }
+          this._checkIfResourceKeyExists(textID, bundles[i].aCustomBundles);
+        }
+      }
+      return false;
+    };
+    return ResourceModel;
+  }(UI5ResourceModel)) || _class);
+  return ResourceModel;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/sap/fe/core/ResourceModel.js

@@ -0,0 +1,6 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2023 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/helpers/ClassSupport","sap/ui/model/resource/ResourceModel"],function(e,t){"use strict";var o,s;var r=e.defineUI5Class;function u(e,t){e.prototype=Object.create(t.prototype);e.prototype.constructor=e;n(e,t)}function n(e,t){n=Object.setPrototypeOf?Object.setPrototypeOf.bind():function e(t,o){t.__proto__=o;return t};return n(e,t)}let c=(o=r("sap.fe.core.ResourceModel"),o(s=function(e){u(t,e);function t(){return e.apply(this,arguments)||this}var o=t.prototype;o.getText=function e(t,o,s){let r=t;const u=this._oResourceBundle;if(s){const e=this.checkIfResourceKeyExists(`${r}|${s}`);r=e?`${r}|${s}`:r}return(u===null||u===void 0?void 0:u.getText(r,o,true))||t};o.checkIfResourceKeyExists=function e(t){return this._checkIfResourceKeyExists(t,this._oResourceBundle.aCustomBundles)};o._checkIfResourceKeyExists=function e(t,o){if(o!==null&&o!==void 0&&o.length){for(let e=o.length-1;e>=0;e--){const s=o[e].hasText(t);if(s){return true}this._checkIfResourceKeyExists(t,o[e].aCustomBundles)}}return false};return t}(t))||s);return c},false);
+//# sourceMappingURL=ResourceModel.js.map

package/src/sap/fe/core/ResourceModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceModel.js","names":["sap","ui","define","ClassSupport","UI5ResourceModel","_dec","_class","defineUI5Class","_inheritsLoose","subClass","superClass","prototype","Object","create","constructor","_setPrototypeOf","o","p","setPrototypeOf","bind","__proto__","ResourceModel","_UI5ResourceModel","apply","this","arguments","_proto","getText","textID","parameters","metaPath","resourceKey","resourceBundle","_oResourceBundle","resourceKeyExists","checkIfResourceKeyExists","_checkIfResourceKeyExists","aCustomBundles","bundles","length","i","sValue","hasText"],"sources":["ResourceModel-dbg.js"],"mappings":";;;;AAIAA,IAAIC,GAAGC,OAAO,CAAC,mCAAoC,uCAAwC,SAAUC,EAAcC,GACjH,aAEA,IAAIC,EAAMC,EACV,IAAIC,EAAiBJ,EAAaI,eAClC,SAASC,EAAeC,EAAUC,GAAcD,EAASE,UAAYC,OAAOC,OAAOH,EAAWC,WAAYF,EAASE,UAAUG,YAAcL,EAAUM,EAAgBN,EAAUC,EAAa,CAC5L,SAASK,EAAgBC,EAAGC,GAAKF,EAAkBH,OAAOM,eAAiBN,OAAOM,eAAeC,OAAS,SAASJ,EAAgBC,EAAGC,GAAKD,EAAEI,UAAYH,EAAG,OAAOD,CAAG,EAAG,OAAOD,EAAgBC,EAAGC,EAAI,CACvM,IAAII,GAAiBhB,EAAOE,EAAe,6BAA8BF,EAAKC,EAAsB,SAAUgB,GAC5Gd,EAAea,EAAeC,GAC9B,SAASD,IACP,OAAOC,EAAkBC,MAAMC,KAAMC,YAAcD,IACrD,CACA,IAAIE,EAASL,EAAcV,UAS3Be,EAAOC,QAAU,SAASA,EAAQC,EAAQC,EAAYC,GACpD,IAAIC,EAAcH,EAClB,MAAMI,EAAiBR,KAAKS,iBAC5B,GAAIH,EAAU,CACZ,MAAMI,EAAoBV,KAAKW,yBAAyB,GAAGJ,KAAeD,KAI1EC,EAAcG,EAAoB,GAAGH,KAAeD,IAAaC,CACnE,CACA,OAAQC,IAAmB,MAAQA,SAAwB,OAAS,EAAIA,EAAeL,QAAQI,EAAaF,EAAY,QAAUD,CACpI,EAQAF,EAAOS,yBAA2B,SAASA,EAAyBP,GAOlE,OAAOJ,KAAKY,0BAA0BR,EAAQJ,KAAKS,iBAAiBI,eACtE,EACAX,EAAOU,0BAA4B,SAASA,EAA0BR,EAAQU,GAC5E,GAAIA,IAAY,MAAQA,SAAiB,GAAKA,EAAQC,OAAQ,CAC5D,IAAK,IAAIC,EAAIF,EAAQC,OAAS,EAAGC,GAAK,EAAGA,IAAK,CAC5C,MAAMC,EAASH,EAAQE,GAAGE,QAAQd,GAElC,GAAIa,EAAQ,CACV,OAAO,IACT,CACAjB,KAAKY,0BAA0BR,EAAQU,EAAQE,GAAGH,eACpD,CACF,CACA,OAAO,KACT,EACA,OAAOhB,CACT,CAxDoG,CAwDlGjB,KAAsBE,GACxB,OAAOe,CACT,EAAG"}

package/src/sap/fe/core/ResourceModel.ts

@@ -0,0 +1,67 @@
+import type ResourceBundle from "sap/base/i18n/ResourceBundle";
+import { defineUI5Class } from "sap/fe/core/helpers/ClassSupport";
+import UI5ResourceModel from "sap/ui/model/resource/ResourceModel";
+
+type InternalResourceBundle = ResourceBundle & {
+	aCustomBundles: InternalResourceBundle[];
+};
+
+@defineUI5Class("sap.fe.core.ResourceModel")
+class ResourceModel extends UI5ResourceModel {
+	private _oResourceBundle!: InternalResourceBundle;
+
+	/**
+	 * Returns text for a given resource key.
+	 *
+	 * @param textID ID of the Text
+	 * @param parameters Array of parameters that are used to create the text
+	 * @param metaPath Entity set name or action name to overload a text
+	 * @returns Determined text
+	 */
+	getText(textID: string, parameters?: unknown[], metaPath?: string): string {
+		let resourceKey = textID;
+		const resourceBundle = this._oResourceBundle;
+
+		if (metaPath) {
+			const resourceKeyExists = this.checkIfResourceKeyExists(`${resourceKey}|${metaPath}`);
+
+			// if resource key with metapath (i.e. entity set name) for instance specific text overriding is provided by the application
+			// then use the same key otherwise use the Framework key
+			resourceKey = resourceKeyExists ? `${resourceKey}|${metaPath}` : resourceKey;
+		}
+
+		return resourceBundle?.getText(resourceKey, parameters, true) || textID;
+	}
+
+	/**
+	 * Check if a text exists for a given resource key.
+	 *
+	 * @param textID ID of the Text
+	 * @returns True in case the text exists
+	 */
+	checkIfResourceKeyExists(textID: string) {
+		// There are console errors logged when making calls to getText for keys that are not defined in the resource bundle
+		// for instance keys which are supposed to be provided by the application, e.g, <key>|<entitySet> to override instance specific text
+		// hence check if text exists (using "hasText") in the resource bundle before calling "getText"
+
+		// "hasText" only checks for the key in the immediate resource bundle and not it's custom bundles
+		// hence we need to do this recurrsively to check if the key exists in any of the bundles the forms the FE resource bundle
+		return this._checkIfResourceKeyExists(textID, this._oResourceBundle.aCustomBundles);
+	}
+
+	_checkIfResourceKeyExists(textID: string, bundles?: InternalResourceBundle[]) {
+		if (bundles?.length) {
+			for (let i = bundles.length - 1; i >= 0; i--) {
+				const sValue = bundles[i].hasText(textID);
+				// text found return true
+				if (sValue) {
+					return true;
+				}
+				this._checkIfResourceKeyExists(textID, bundles[i].aCustomBundles);
+			}
+		}
+		return false;
+	}
+}
+
+export default ResourceModel;

package/src/sap/fe/core/TemplateComponent-dbg.js

@@ -215,4 +215,4 @@ sap.ui.define(["sap/fe/core/CommonUtils", "sap/fe/core/helpers/ClassSupport", "s
   })), _class2)) || _class);
   return TemplateComponent;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["TemplateComponent","defineUI5Class","implementInterface","property","type","defaultValue","event","setContainer","oContainer","fireEvent","container","init","oAppComponent","CommonUtils","getAppComponent","oStateChangeHandler","oEvent","oControl","getParameter","isA","oMacroAPI","getParent","fireStateChange","StateUtil","detachStateChange","attachStateChange","getExtensionComponent","getRootController","rootControl","getRootControl","rootController","getController","onPageReady","mParameters","getNavigationConfiguration","sTargetPath","mNavigation","navigation","getViewData","mProperties","getMetadata","getAllProperties","oViewData","Object","keys","reduce","mViewData","sPropertyName","get","fclEnabled","_isFclEnabled","_getPageTitleInformation","getExtensionAPI","UIComponent"],"sourceRoot":".","sources":["TemplateComponent.ts"],"sourcesContent":["import type AppComponent from \"sap/fe/core/AppComponent\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport type ConverterContext from \"sap/fe/core/converters/ConverterContext\";\nimport { defineUI5Class, event, implementInterface, property } from \"sap/fe/core/helpers/ClassSupport\";\nimport type PageController from \"sap/fe/core/PageController\";\nimport type Event from \"sap/ui/base/Event\";\nimport type ComponentContainer from \"sap/ui/core/ComponentContainer\";\nimport type { IAsyncContentCreation } from \"sap/ui/core/library\";\nimport type View from \"sap/ui/core/mvc/View\";\nimport UIComponent from \"sap/ui/core/UIComponent\";\nimport StateUtil from \"sap/ui/mdc/p13n/StateUtil\";\nimport type ODataListBinding from \"sap/ui/model/odata/v4/ODataListBinding\";\n\ntype NavigationConfiguration = {\n\tdetail: {\n\t\troute: string;\n\t\tparameters: unknown;\n\t};\n};\n\n@defineUI5Class(\"sap.fe.core.TemplateComponent\")\nclass TemplateComponent extends UIComponent implements IAsyncContentCreation {\n\t@implementInterface(\"sap.ui.core.IAsyncContentCreation\")\n\t__implements__sap_ui_core_IAsyncContentCreation = true;\n\n\t/**\n\t * Name of the OData entity set\n\t */\n\t@property({ type: \"string\", defaultValue: null })\n\tentitySet: string | null = null;\n\n\t/**\n\t * Context Path for rendering the template\n\t */\n\t@property({ type: \"string\", defaultValue: null })\n\tcontextPath: string | null = null;\n\n\t/**\n\t * The pattern for the binding context to be create based on the parameters from the navigation\n\t * If not provided we'll default to what was passed in the URL\n\t */\n\t@property({ type: \"string\" })\n\tbindingContextPattern!: string;\n\n\t/**\n\t * Map of used OData navigations and its routing targets\n\t */\n\t@property({ type: \"object\" })\n\tnavigation!: Record<string, NavigationConfiguration>;\n\n\t/**\n\t * Enhance the i18n bundle used for this page with one or more app specific i18n resource bundles or resource models\n\t * or a combination of both. The last resource bundle/model is given highest priority\n\t */\n\t@property({ type: \"string[]\" })\n\tenhanceI18n!: string[];\n\n\t/**\n\t * Define control related configuration settings\n\t */\n\t@property({ type: \"object\" })\n\tcontrolConfiguration?: Record<string, unknown>;\n\n\t/**\n\t * Adjusts the template content\n\t */\n\t@property({ type: \"object\" })\n\tcontent?: Record<string, unknown>;\n\n\t/**\n\t * Whether or not you can reach this page directly through semantic bookmarks\n\t */\n\t@property({ type: \"boolean\" })\n\tallowDeepLinking!: boolean;\n\t/**\n\t * Defines the context path on the component that is refreshed when the app is restored using keep alive mode\n\t */\n\t@property({ type: \"object\" })\n\trefreshStrategyOnAppRestore: unknown;\n\n\t@property({ type: \"string\" })\n\tviewType = \"XML\";\n\n\t@event()\n\tcontainerDefined!: Function;\n\n\t@event()\n\theroesBatchReceived!: Function;\n\n\t@event()\n\tworkersBatchReceived!: Function;\n\n\tprotected oAppComponent!: AppComponent;\n\n\tsetContainer(oContainer: ComponentContainer): this {\n\t\tsuper.setContainer(oContainer);\n\t\tthis.fireEvent(\"containerDefined\", { container: oContainer });\n\t\treturn this;\n\t}\n\n\tinit() {\n\t\tthis.oAppComponent = CommonUtils.getAppComponent(this);\n\t\tsuper.init();\n\t\tconst oStateChangeHandler = function (oEvent: Event) {\n\t\t\tconst oControl = oEvent.getParameter(\"control\");\n\t\t\tif (oControl.isA(\"sap.ui.mdc.Table\") || oControl.isA(\"sap.ui.mdc.FilterBar\") || oControl.isA(\"sap.ui.mdc.Chart\")) {\n\t\t\t\tconst oMacroAPI = oControl.getParent();\n\t\t\t\tif (oMacroAPI?.fireStateChange) {\n\t\t\t\t\toMacroAPI.fireStateChange();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t\tStateUtil.detachStateChange(oStateChangeHandler);\n\t\tStateUtil.attachStateChange(oStateChangeHandler);\n\t}\n\n\t// This method is called by UI5 core to access to the component containing the customizing configuration.\n\t// as controller extensions are defined in the manifest for the app component and not for the\n\t// template component we return the app component.\n\tgetExtensionComponent(): AppComponent {\n\t\treturn this.oAppComponent;\n\t}\n\n\tgetRootController(): PageController | undefined {\n\t\tconst rootControl: View = this.getRootControl();\n\t\tlet rootController: PageController | undefined;\n\t\tif (rootControl && rootControl.getController) {\n\t\t\trootController = rootControl.getController() as PageController;\n\t\t}\n\t\treturn rootController;\n\t}\n\n\tonPageReady(mParameters: unknown) {\n\t\tconst rootController = this.getRootController();\n\t\tif (rootController && rootController.onPageReady) {\n\t\t\trootController.onPageReady(mParameters);\n\t\t}\n\t}\n\n\tgetNavigationConfiguration(sTargetPath: string): NavigationConfiguration {\n\t\tconst mNavigation = this.navigation;\n\t\treturn mNavigation[sTargetPath];\n\t}\n\n\tgetViewData() {\n\t\tconst mProperties = this.getMetadata().getAllProperties();\n\t\tconst oViewData = Object.keys(mProperties).reduce((mViewData: Record<string, unknown>, sPropertyName: string) => {\n\t\t\tmViewData[sPropertyName] = mProperties[sPropertyName].get!(this);\n\t\t\treturn mViewData;\n\t\t}, {});\n\n\t\t// Access the internal _isFclEnabled which will be there\n\t\toViewData.fclEnabled = this.oAppComponent._isFclEnabled();\n\n\t\treturn oViewData;\n\t}\n\n\t_getPageTitleInformation() {\n\t\tconst rootControl = this.getRootControl();\n\t\tif (rootControl && rootControl.getController() && rootControl.getController()._getPageTitleInformation) {\n\t\t\treturn rootControl.getController()._getPageTitleInformation();\n\t\t} else {\n\t\t\treturn {};\n\t\t}\n\t}\n\n\tgetExtensionAPI() {\n\t\treturn this.getRootControl().getController().getExtensionAPI();\n\t}\n}\ninterface TemplateComponent {\n\t// TODO: this should be ideally be handled by the editflow/routing without the need to have this method in the object page - for now keep it here\n\tcreateDeferredContext?(sPath: string, oListBinding: ODataListBinding, bActionCreate: boolean): void;\n\tgetRootControl(): { getController(): PageController } & View;\n\textendPageDefinition?(pageDefinition: {}, converterContext?: ConverterContext): {};\n}\nexport default TemplateComponent;\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["TemplateComponent","defineUI5Class","implementInterface","property","type","defaultValue","event","setContainer","oContainer","fireEvent","container","init","oAppComponent","CommonUtils","getAppComponent","oStateChangeHandler","oEvent","oControl","getParameter","isA","oMacroAPI","getParent","fireStateChange","StateUtil","detachStateChange","attachStateChange","getExtensionComponent","getRootController","rootControl","getRootControl","rootController","getController","onPageReady","mParameters","getNavigationConfiguration","sTargetPath","mNavigation","navigation","getViewData","mProperties","getMetadata","getAllProperties","oViewData","Object","keys","reduce","mViewData","sPropertyName","get","fclEnabled","_isFclEnabled","_getPageTitleInformation","getExtensionAPI","UIComponent"],"sourceRoot":".","sources":["TemplateComponent.ts"],"sourcesContent":["import type AppComponent from \"sap/fe/core/AppComponent\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport type ConverterContext from \"sap/fe/core/converters/ConverterContext\";\nimport { defineUI5Class, event, implementInterface, property } from \"sap/fe/core/helpers/ClassSupport\";\nimport type PageController from \"sap/fe/core/PageController\";\nimport type Event from \"sap/ui/base/Event\";\nimport type ComponentContainer from \"sap/ui/core/ComponentContainer\";\nimport type { IAsyncContentCreation } from \"sap/ui/core/library\";\nimport type View from \"sap/ui/core/mvc/View\";\nimport UIComponent from \"sap/ui/core/UIComponent\";\nimport StateUtil from \"sap/ui/mdc/p13n/StateUtil\";\nimport type ODataListBinding from \"sap/ui/model/odata/v4/ODataListBinding\";\n\ntype NavigationConfiguration = {\n\tdetail: {\n\t\troute: string;\n\t\tparameters: unknown;\n\t};\n};\n\n@defineUI5Class(\"sap.fe.core.TemplateComponent\")\nclass TemplateComponent extends UIComponent implements IAsyncContentCreation {\n\t@implementInterface(\"sap.ui.core.IAsyncContentCreation\")\n\t__implements__sap_ui_core_IAsyncContentCreation = true;\n\n\t/**\n\t * Name of the OData entity set\n\t */\n\t@property({ type: \"string\", defaultValue: null })\n\tentitySet: string | null = null;\n\n\t/**\n\t * Context Path for rendering the template\n\t */\n\t@property({ type: \"string\", defaultValue: null })\n\tcontextPath: string | null = null;\n\n\t/**\n\t * The pattern for the binding context to be create based on the parameters from the navigation\n\t * If not provided we'll default to what was passed in the URL\n\t */\n\t@property({ type: \"string\" })\n\tbindingContextPattern!: string;\n\n\t/**\n\t * Map of used OData navigations and its routing targets\n\t */\n\t@property({ type: \"object\" })\n\tnavigation!: Record<string, NavigationConfiguration>;\n\n\t/**\n\t * Enhance the i18n bundle used for this page with one or more app specific i18n resource bundles or resource models\n\t * or a combination of both. The last resource bundle/model is given highest priority\n\t */\n\t@property({ type: \"string[]\" })\n\tenhanceI18n!: string[];\n\n\t/**\n\t * Define control related configuration settings\n\t */\n\t@property({ type: \"object\" })\n\tcontrolConfiguration?: Record<string, unknown>;\n\n\t/**\n\t * Adjusts the template content\n\t */\n\t@property({ type: \"object\" })\n\tcontent?: Record<string, unknown>;\n\n\t/**\n\t * Whether or not you can reach this page directly through semantic bookmarks\n\t */\n\t@property({ type: \"boolean\" })\n\tallowDeepLinking!: boolean;\n\n\t/**\n\t * Defines the context path on the component that is refreshed when the app is restored using keep alive mode\n\t */\n\t@property({ type: \"object\" })\n\trefreshStrategyOnAppRestore: unknown;\n\n\t@property({ type: \"string\" })\n\tviewType = \"XML\";\n\n\t@event()\n\tcontainerDefined!: Function;\n\n\t@event()\n\theroesBatchReceived!: Function;\n\n\t@event()\n\tworkersBatchReceived!: Function;\n\n\tprotected oAppComponent!: AppComponent;\n\n\tsetContainer(oContainer: ComponentContainer): this {\n\t\tsuper.setContainer(oContainer);\n\t\tthis.fireEvent(\"containerDefined\", { container: oContainer });\n\t\treturn this;\n\t}\n\n\tinit() {\n\t\tthis.oAppComponent = CommonUtils.getAppComponent(this);\n\t\tsuper.init();\n\t\tconst oStateChangeHandler = function (oEvent: Event) {\n\t\t\tconst oControl = oEvent.getParameter(\"control\");\n\t\t\tif (oControl.isA(\"sap.ui.mdc.Table\") || oControl.isA(\"sap.ui.mdc.FilterBar\") || oControl.isA(\"sap.ui.mdc.Chart\")) {\n\t\t\t\tconst oMacroAPI = oControl.getParent();\n\t\t\t\tif (oMacroAPI?.fireStateChange) {\n\t\t\t\t\toMacroAPI.fireStateChange();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t\tStateUtil.detachStateChange(oStateChangeHandler);\n\t\tStateUtil.attachStateChange(oStateChangeHandler);\n\t}\n\n\t// This method is called by UI5 core to access to the component containing the customizing configuration.\n\t// as controller extensions are defined in the manifest for the app component and not for the\n\t// template component we return the app component.\n\tgetExtensionComponent(): AppComponent {\n\t\treturn this.oAppComponent;\n\t}\n\n\tgetRootController(): PageController | undefined {\n\t\tconst rootControl: View = this.getRootControl();\n\t\tlet rootController: PageController | undefined;\n\t\tif (rootControl && rootControl.getController) {\n\t\t\trootController = rootControl.getController() as PageController;\n\t\t}\n\t\treturn rootController;\n\t}\n\n\tonPageReady(mParameters: unknown) {\n\t\tconst rootController = this.getRootController();\n\t\tif (rootController && rootController.onPageReady) {\n\t\t\trootController.onPageReady(mParameters);\n\t\t}\n\t}\n\n\tgetNavigationConfiguration(sTargetPath: string): NavigationConfiguration {\n\t\tconst mNavigation = this.navigation;\n\t\treturn mNavigation[sTargetPath];\n\t}\n\n\tgetViewData() {\n\t\tconst mProperties = this.getMetadata().getAllProperties();\n\t\tconst oViewData = Object.keys(mProperties).reduce((mViewData: Record<string, unknown>, sPropertyName: string) => {\n\t\t\tmViewData[sPropertyName] = mProperties[sPropertyName].get!(this);\n\t\t\treturn mViewData;\n\t\t}, {});\n\n\t\t// Access the internal _isFclEnabled which will be there\n\t\toViewData.fclEnabled = this.oAppComponent._isFclEnabled();\n\n\t\treturn oViewData;\n\t}\n\n\t_getPageTitleInformation() {\n\t\tconst rootControl = this.getRootControl();\n\t\tif (rootControl && rootControl.getController() && rootControl.getController()._getPageTitleInformation) {\n\t\t\treturn rootControl.getController()._getPageTitleInformation();\n\t\t} else {\n\t\t\treturn {};\n\t\t}\n\t}\n\n\tgetExtensionAPI() {\n\t\treturn this.getRootControl().getController().getExtensionAPI();\n\t}\n}\ninterface TemplateComponent {\n\t// TODO: this should be ideally be handled by the editflow/routing without the need to have this method in the object page - for now keep it here\n\tcreateDeferredContext?(sPath: string, oListBinding: ODataListBinding, bActionCreate: boolean): void;\n\tgetRootControl(): { getController(): PageController } & View;\n\textendPageDefinition?(pageDefinition: {}, converterContext?: ConverterContext): {};\n}\nexport default TemplateComponent;\n"],"mappings":"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"}

package/src/sap/fe/core/TemplateComponent.ts

@@ -72,6 +72,7 @@ class TemplateComponent extends UIComponent implements IAsyncContentCreation {
 	 */
 	@property({ type: "boolean" })
 	allowDeepLinking!: boolean;
+
 	/**
 	 * Defines the context path on the component that is refreshed when the app is restored using keep alive mode
 	 */

package/src/sap/fe/core/TemplateModel-dbg.js

@@ -72,4 +72,4 @@ sap.ui.define(["sap/fe/core/helpers/ClassSupport", "sap/ui/base/Object", "sap/ui
   }(BaseObject)) || _class);
   return TemplateModel;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/sap/fe/core/TemplateModel.ts

@@ -11,10 +11,15 @@ type InternalJSONModel = JSONModel & {
 @defineUI5Class("sap.fe.core.TemplateModel")
 class TemplateModel extends BaseObject {
 	public oMetaModel: ODataMetaModel;
+
 	public oConfigModel: JSONModel;
+
 	public bConfigLoaded: boolean;
+
 	public fnCreateMetaBindingContext: Function;
+
 	public fnCreateConfigBindingContext: Function;
+
 	public fnSetData: Function;
 
 	constructor(pageConfig: Function | object, oMetaModel: ODataMetaModel) {
@@ -60,7 +65,7 @@ class TemplateModel extends BaseObject {
 		this.bConfigLoaded = true;
 	}
 
-	createBindingContext(sPath: string, oContext?: Context, mParameters?: { noResolve?: boolean }, fnCallBack?: Function) {
+	createBindingContext(sPath: string, oContext?: Context, mParameters?: { noResolve?: boolean }, fnCallBack?: Function): Context {
 		let oBindingContext;
 		const bNoResolve = mParameters && mParameters.noResolve;
 

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

@@ -13,12 +13,12 @@ sap.ui.define(["sap/base/Log", "sap/base/util/ObjectPath", "sap/ui/model/json/JS
    */
   let AttributeModel = /*#__PURE__*/function (_JSONModel) {
     _inheritsLoose(AttributeModel, _JSONModel);
-    function AttributeModel(oNode, oProps, buildingBlockDefinition) {
+    function AttributeModel(oNode, oProps, BuildingBlockClass) {
       var _this;
       _this = _JSONModel.call(this) || this;
       _this.oNode = oNode;
       _this.oProps = oProps;
-      _this.buildingBlockDefinition = buildingBlockDefinition;
+      _this.BuildingBlockClass = BuildingBlockClass;
       _this.$$valueAsPromise = true;
       return _this;
     }
@@ -43,15 +43,13 @@ sap.ui.define(["sap/base/Log", "sap/base/util/ObjectPath", "sap/ui/model/json/JS
         return this.oProps[sPath];
       }
       if (sPath.indexOf(":") === -1 && sPath.indexOf("/") === -1) {
-        // Gloves are off, if you have this error you forgot to define your property on your metadata but are still using it in the underlying code
-        Log.error(`Missing property ${sPath} on building block metadata ${this.buildingBlockDefinition.name}`);
-        //throw new Error(`Missing property ${sPath} on macro metadata ${this.buildingBlockDefinition.name}`);
+        // Gloves are off, if you have this error you forgot to decorate your property with @blockAttribute but are still using it in underlying templating
+        Log.error(`Missing property ${sPath} on building block metadata ${this.BuildingBlockClass.name}`);
       }
-
       return this.oNode.getAttribute(sPath);
     };
     return AttributeModel;
   }(JSONModel);
   return AttributeModel;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -2,5 +2,5 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2023 SAP SE. All rights reserved
  */
-sap.ui.define(["sap/base/Log","sap/base/util/ObjectPath","sap/ui/model/json/JSONModel"],function(t,e,n){"use strict";function i(t,e){t.prototype=Object.create(e.prototype);t.prototype.constructor=t;o(t,e)}function o(t,e){o=Object.setPrototypeOf?Object.setPrototypeOf.bind():function t(e,n){e.__proto__=n;return e};return o(t,e)}let r=function(n){i(o,n);function o(t,e,i){var o;o=n.call(this)||this;o.oNode=t;o.oProps=e;o.buildingBlockDefinition=i;o.$$valueAsPromise=true;return o}var r=o.prototype;r._getObject=function n(i,o){if(i===undefined||i===""){if(o!==undefined&&o.getPath()!=="/"){return this._getObject(o.getPath(i))}return this.oProps}if(i==="/undefinedValue"||i==="undefinedValue"){return undefined}const r=e.get(i.replace(/\//g,"."),this.oProps);if(r!==undefined){return r}if(this.oProps.hasOwnProperty(i)){return this.oProps[i]}if(i.indexOf(":")===-1&&i.indexOf("/")===-1){t.error(`Missing property ${i} on building block metadata ${this.buildingBlockDefinition.name}`)}return this.oNode.getAttribute(i)};return o}(n);return r},false);
+sap.ui.define(["sap/base/Log","sap/base/util/ObjectPath","sap/ui/model/json/JSONModel"],function(t,e,n){"use strict";function r(t,e){t.prototype=Object.create(e.prototype);t.prototype.constructor=t;o(t,e)}function o(t,e){o=Object.setPrototypeOf?Object.setPrototypeOf.bind():function t(e,n){e.__proto__=n;return e};return o(t,e)}let i=function(n){r(o,n);function o(t,e,r){var o;o=n.call(this)||this;o.oNode=t;o.oProps=e;o.BuildingBlockClass=r;o.$$valueAsPromise=true;return o}var i=o.prototype;i._getObject=function n(r,o){if(r===undefined||r===""){if(o!==undefined&&o.getPath()!=="/"){return this._getObject(o.getPath(r))}return this.oProps}if(r==="/undefinedValue"||r==="undefinedValue"){return undefined}const i=e.get(r.replace(/\//g,"."),this.oProps);if(i!==undefined){return i}if(this.oProps.hasOwnProperty(r)){return this.oProps[r]}if(r.indexOf(":")===-1&&r.indexOf("/")===-1){t.error(`Missing property ${r} on building block metadata ${this.BuildingBlockClass.name}`)}return this.oNode.getAttribute(r)};return o}(n);return i},false);
 //# sourceMappingURL=AttributeModel.js.map

package/src/sap/fe/core/buildingBlocks/AttributeModel.js.map

@@ -1 +1 @@
-{"version":3,"file":"AttributeModel.js","names":["sap","ui","define","Log","ObjectPath","JSONModel","_inheritsLoose","subClass","superClass","prototype","Object","create","constructor","_setPrototypeOf","o","p","setPrototypeOf","bind","__proto__","AttributeModel","_JSONModel","oNode","oProps","buildingBlockDefinition","_this","call","this","$$valueAsPromise","_proto","_getObject","sPath","oContext","undefined","getPath","oValue","get","replace","hasOwnProperty","indexOf","error","name","getAttribute"],"sources":["AttributeModel-dbg.js"],"mappings":";;;;AAIAA,IAAIC,GAAGC,OAAO,CAAC,eAAgB,2BAA4B,+BAAgC,SAAUC,EAAKC,EAAYC,GACpH,aAEA,SAASC,EAAeC,EAAUC,GAAcD,EAASE,UAAYC,OAAOC,OAAOH,EAAWC,WAAYF,EAASE,UAAUG,YAAcL,EAAUM,EAAgBN,EAAUC,EAAa,CAC5L,SAASK,EAAgBC,EAAGC,GAAKF,EAAkBH,OAAOM,eAAiBN,OAAOM,eAAeC,OAAS,SAASJ,EAAgBC,EAAGC,GAAKD,EAAEI,UAAYH,EAAG,OAAOD,CAAG,EAAG,OAAOD,EAAgBC,EAAGC,EAAI,CAKvM,IAAII,EAA8B,SAAUC,GAC1Cd,EAAea,EAAgBC,GAC/B,SAASD,EAAeE,EAAOC,EAAQC,GACrC,IAAIC,EACJA,EAAQJ,EAAWK,KAAKC,OAASA,KACjCF,EAAMH,MAAQA,EACdG,EAAMF,OAASA,EACfE,EAAMD,wBAA0BA,EAChCC,EAAMG,iBAAmB,KACzB,OAAOH,CACT,CACA,IAAII,EAAST,EAAeV,UAC5BmB,EAAOC,WAAa,SAASA,EAAWC,EAAOC,GAC7C,GAAID,IAAUE,WAAaF,IAAU,GAAI,CACvC,GAAIC,IAAaC,WAAaD,EAASE,YAAc,IAAK,CACxD,OAAOP,KAAKG,WAAWE,EAASE,QAAQH,GAC1C,CACA,OAAOJ,KAAKJ,MACd,CACA,GAAIQ,IAAU,mBAAqBA,IAAU,iBAAkB,CAC7D,OAAOE,SACT,CAEA,MAAME,EAAS9B,EAAW+B,IAAIL,EAAMM,QAAQ,MAAO,KAAMV,KAAKJ,QAC9D,GAAIY,IAAWF,UAAW,CACxB,OAAOE,CACT,CAEA,GAAIR,KAAKJ,OAAOe,eAAeP,GAAQ,CACrC,OAAOJ,KAAKJ,OAAOQ,EACrB,CACA,GAAIA,EAAMQ,QAAQ,QAAU,GAAKR,EAAMQ,QAAQ,QAAU,EAAG,CAE1DnC,EAAIoC,MAAM,oBAAoBT,gCAAoCJ,KAAKH,wBAAwBiB,OAEjG,CAEA,OAAOd,KAAKL,MAAMoB,aAAaX,EACjC,EACA,OAAOX,CACT,CAxCkC,CAwChCd,GACF,OAAOc,CACT,EAAG"}
+{"version":3,"file":"AttributeModel.js","names":["sap","ui","define","Log","ObjectPath","JSONModel","_inheritsLoose","subClass","superClass","prototype","Object","create","constructor","_setPrototypeOf","o","p","setPrototypeOf","bind","__proto__","AttributeModel","_JSONModel","oNode","oProps","BuildingBlockClass","_this","call","this","$$valueAsPromise","_proto","_getObject","sPath","oContext","undefined","getPath","oValue","get","replace","hasOwnProperty","indexOf","error","name","getAttribute"],"sources":["AttributeModel-dbg.js"],"mappings":";;;;AAIAA,IAAIC,GAAGC,OAAO,CAAC,eAAgB,2BAA4B,+BAAgC,SAAUC,EAAKC,EAAYC,GACpH,aAEA,SAASC,EAAeC,EAAUC,GAAcD,EAASE,UAAYC,OAAOC,OAAOH,EAAWC,WAAYF,EAASE,UAAUG,YAAcL,EAAUM,EAAgBN,EAAUC,EAAa,CAC5L,SAASK,EAAgBC,EAAGC,GAAKF,EAAkBH,OAAOM,eAAiBN,OAAOM,eAAeC,OAAS,SAASJ,EAAgBC,EAAGC,GAAKD,EAAEI,UAAYH,EAAG,OAAOD,CAAG,EAAG,OAAOD,EAAgBC,EAAGC,EAAI,CAKvM,IAAII,EAA8B,SAAUC,GAC1Cd,EAAea,EAAgBC,GAC/B,SAASD,EAAeE,EAAOC,EAAQC,GACrC,IAAIC,EACJA,EAAQJ,EAAWK,KAAKC,OAASA,KACjCF,EAAMH,MAAQA,EACdG,EAAMF,OAASA,EACfE,EAAMD,mBAAqBA,EAC3BC,EAAMG,iBAAmB,KACzB,OAAOH,CACT,CACA,IAAII,EAAST,EAAeV,UAC5BmB,EAAOC,WAAa,SAASA,EAAWC,EAAOC,GAC7C,GAAID,IAAUE,WAAaF,IAAU,GAAI,CACvC,GAAIC,IAAaC,WAAaD,EAASE,YAAc,IAAK,CACxD,OAAOP,KAAKG,WAAWE,EAASE,QAAQH,GAC1C,CACA,OAAOJ,KAAKJ,MACd,CACA,GAAIQ,IAAU,mBAAqBA,IAAU,iBAAkB,CAC7D,OAAOE,SACT,CAEA,MAAME,EAAS9B,EAAW+B,IAAIL,EAAMM,QAAQ,MAAO,KAAMV,KAAKJ,QAC9D,GAAIY,IAAWF,UAAW,CACxB,OAAOE,CACT,CAEA,GAAIR,KAAKJ,OAAOe,eAAeP,GAAQ,CACrC,OAAOJ,KAAKJ,OAAOQ,EACrB,CACA,GAAIA,EAAMQ,QAAQ,QAAU,GAAKR,EAAMQ,QAAQ,QAAU,EAAG,CAE1DnC,EAAIoC,MAAM,oBAAoBT,gCAAoCJ,KAAKH,mBAAmBiB,OAC5F,CACA,OAAOd,KAAKL,MAAMoB,aAAaX,EACjC,EACA,OAAOX,CACT,CAtCkC,CAsChCd,GACF,OAAOc,CACT,EAAG"}

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

@@ -1,6 +1,6 @@
 import Log from "sap/base/Log";
 import ObjectPath from "sap/base/util/ObjectPath";
-import type { BuildingBlockDefinition } from "sap/fe/core/buildingBlocks/BuildingBlock";
+import type BuildingBlockBase from "sap/fe/core/buildingBlocks/BuildingBlockBase";
 import type Context from "sap/ui/model/Context";
 import JSONModel from "sap/ui/model/json/JSONModel";
 
@@ -10,14 +10,16 @@ import JSONModel from "sap/ui/model/json/JSONModel";
  */
 class AttributeModel extends JSONModel {
 	public $$valueAsPromise: boolean;
+
 	constructor(
 		private readonly oNode: Element,
 		private readonly oProps: Record<string, unknown>,
-		private readonly buildingBlockDefinition: BuildingBlockDefinition
+		private readonly BuildingBlockClass: typeof BuildingBlockBase
 	) {
 		super();
 		this.$$valueAsPromise = true;
 	}
+
 	_getObject(sPath: string, oContext?: Context): unknown {
 		if (sPath === undefined || sPath === "") {
 			if (oContext !== undefined && oContext.getPath() !== "/") {
@@ -38,9 +40,8 @@ class AttributeModel extends JSONModel {
 			return this.oProps[sPath];
 		}
 		if (sPath.indexOf(":") === -1 && sPath.indexOf("/") === -1) {
-			// Gloves are off, if you have this error you forgot to define your property on your metadata but are still using it in the underlying code
-			Log.error(`Missing property ${sPath} on building block metadata ${this.buildingBlockDefinition.name}`);
-			//throw new Error(`Missing property ${sPath} on macro metadata ${this.buildingBlockDefinition.name}`);
+			// Gloves are off, if you have this error you forgot to decorate your property with @blockAttribute but are still using it in underlying templating
+			Log.error(`Missing property ${sPath} on building block metadata ${this.BuildingBlockClass.name}`);
 		}
 		return this.oNode.getAttribute(sPath);
 	}

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

@@ -0,0 +1,163 @@
+/*!
+ * 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/fe/core/buildingBlocks/BuildingBlockTemplateProcessor", "sap/fe/core/converters/ConverterContext", "sap/fe/core/helpers/BindingToolkit", "sap/fe/core/helpers/StableIdHelper"], function (deepClone, merge, BuildingBlockTemplateProcessor, ConverterContext, BindingToolkit, StableIdHelper) {
+  "use strict";
+
+  var _exports = {};
+  var generate = StableIdHelper.generate;
+  var isUndefinedExpression = BindingToolkit.isUndefinedExpression;
+  var xml = BuildingBlockTemplateProcessor.xml;
+  var unregisterBuildingBlock = BuildingBlockTemplateProcessor.unregisterBuildingBlock;
+  var registerBuildingBlock = BuildingBlockTemplateProcessor.registerBuildingBlock;
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+  function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+  function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+  /**
+   * Base class for building blocks
+   */
+  let BuildingBlockBase = /*#__PURE__*/function () {
+    function BuildingBlockBase(props, _controlConfiguration, _visitorSettings) {
+      var _visitorSettings$mode;
+      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.resourceModel;
+        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];
+      });
+      this.resourceModel = _visitorSettings === null || _visitorSettings === void 0 ? void 0 : (_visitorSettings$mode = _visitorSettings.models) === null || _visitorSettings$mode === void 0 ? void 0 : _visitorSettings$mode["sap.fe.i18n"];
+    }
+
+    /**
+     * Only used internally
+     *
+     * @private
+     */
+    _exports = 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;
+    }
+
+    /**
+     * Get the ID of the content control.
+     *
+     * @param buildingBlockId
+     * @returns Return the ID
+     * @private
+     */;
+    _proto.getContentId = function getContentId(buildingBlockId) {
+      return `${buildingBlockId}-content`;
+    }
+
+    /**
+     * Returns translated text for a given resource key.
+     *
+     * @param textID ID of the Text
+     * @param parameters Array of parameters that are used to create the text
+     * @param metaPath Entity set name or action name to overload a text
+     * @returns Determined text
+     */;
+    _proto.getTranslatedText = function getTranslatedText(textID, parameters, metaPath) {
+      var _this$resourceModel;
+      return ((_this$resourceModel = this.resourceModel) === null || _this$resourceModel === void 0 ? void 0 : _this$resourceModel.getText(textID, parameters, metaPath)) || textID;
+    };
+    /**
+     * 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() {
+      registerBuildingBlock(this);
+    };
+    BuildingBlockBase.unregister = function unregister() {
+      unregisterBuildingBlock(this);
+    }
+
+    /**
+     * 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 () => "";
+      }
+    };
+    _createClass(BuildingBlockBase, null, [{
+      key: "metadata",
+      get: function () {
+        // We need to store the metadata on the actual subclass, not on BuildingBlockBase
+        this.internalMetadata ??= {
+          namespace: "",
+          name: "",
+          properties: {},
+          aggregations: {},
+          stereotype: "xmlmacro"
+        };
+        return this.internalMetadata;
+      }
+    }]);
+    return BuildingBlockBase;
+  }();
+  BuildingBlockBase.isRuntime = false;
+  _exports = BuildingBlockBase;
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["BuildingBlockBase","props","_controlConfiguration","_visitorSettings","isPublic","getConverterContext","dataModelObjectPath","contextPath","settings","extraParams","appComponent","originalViewData","models","viewData","getData","Object","assign","resourceModel","deepClone","controlConfiguration","merge","ConverterContext","createConverterContextForMacro","startingEntitySet","name","metaModel","getDiagnostics","contextLocation","keys","forEach","propName","createId","id","stringParts","generate","undefined","getContentId","buildingBlockId","getTranslatedText","textID","parameters","metaPath","getText","getProperties","allProperties","oInstanceKey","hasOwnProperty","register","registerBuildingBlock","unregister","unregisterBuildingBlock","addConditionally","condition","partToAdd","attr","attributeName","value","isUndefinedExpression","xml","internalMetadata","namespace","properties","aggregations","stereotype","isRuntime"],"sourceRoot":".","sources":["BuildingBlockBase.ts"],"sourcesContent":["import deepClone from \"sap/base/util/deepClone\";\nimport merge from \"sap/base/util/merge\";\nimport type { BuildingBlockMetadata, ObjectValue } from \"sap/fe/core/buildingBlocks/BuildingBlockSupport\";\nimport type { TemplateProcessorSettings, XMLProcessorTypeValue } from \"sap/fe/core/buildingBlocks/BuildingBlockTemplateProcessor\";\nimport { registerBuildingBlock, unregisterBuildingBlock, xml } from \"sap/fe/core/buildingBlocks/BuildingBlockTemplateProcessor\";\nimport ConverterContext from \"sap/fe/core/converters/ConverterContext\";\nimport { isUndefinedExpression } from \"sap/fe/core/helpers/BindingToolkit\";\nimport { generate } from \"sap/fe/core/helpers/StableIdHelper\";\nimport type ResourceModel from \"sap/fe/core/ResourceModel\";\nimport type { DataModelObjectPath } from \"sap/fe/core/templating/DataModelPathHelper\";\n\n/**\n * Base class for building blocks\n */\nexport default class BuildingBlockBase {\n\tprivate static internalMetadata: BuildingBlockMetadata;\n\n\tpublic static get metadata(): BuildingBlockMetadata {\n\t\t// We need to store the metadata on the actual subclass, not on BuildingBlockBase\n\t\tthis.internalMetadata ??= {\n\t\t\tnamespace: \"\",\n\t\t\tname: \"\",\n\t\t\tproperties: {},\n\t\t\taggregations: {},\n\t\t\tstereotype: \"xmlmacro\"\n\t\t};\n\t\treturn this.internalMetadata;\n\t}\n\n\tpublic static readonly isRuntime: boolean = false;\n\n\tprotected isPublic = false;\n\n\tprivate resourceModel?: ResourceModel;\n\n\tprotected id?: string;\n\n\tconstructor(props: Record<string, unknown>, _controlConfiguration?: unknown, _visitorSettings?: TemplateProcessorSettings) {\n\t\tObject.keys(props).forEach((propName) => {\n\t\t\tthis[propName as keyof this] = props[propName] as never;\n\t\t});\n\n\t\tthis.resourceModel = _visitorSettings?.models?.[\"sap.fe.i18n\"];\n\t}\n\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\n\t/**\n\t * Get the ID of the content control.\n\t *\n\t * @param buildingBlockId\n\t * @returns Return the ID\n\t * @private\n\t */\n\tprotected getContentId(buildingBlockId: string) {\n\t\treturn `${buildingBlockId}-content`;\n\t}\n\n\t/**\n\t * Returns translated text for a given resource key.\n\t *\n\t * @param textID ID of the Text\n\t * @param parameters Array of parameters that are used to create the text\n\t * @param metaPath Entity set name or action name to overload a text\n\t * @returns Determined text\n\t */\n\tgetTranslatedText(textID: string, parameters?: unknown[], metaPath?: string): string {\n\t\treturn this.resourceModel?.getText(textID, parameters, metaPath) || textID;\n\t}\n\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.resourceModel;\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\n\tstatic register() {\n\t\tregisterBuildingBlock(this);\n\t}\n\n\tstatic unregister() {\n\t\tunregisterBuildingBlock(this);\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\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"],"mappings":"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"}