@sapui5/sap.fe.core 1.124.2 → 1.126.0

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

@@ -0,0 +1,172 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2024 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/Log", "sap/fe/base/ClassSupport", "sap/fe/core/fpm/Component", "sap/ui/core/Component"], function (Log, ClassSupport, FPMComponent, Component) {
+  "use strict";
+
+  var _dec, _dec2, _dec3, _class, _class2, _descriptor, _descriptor2;
+  var property = ClassSupport.property;
+  var event = ClassSupport.event;
+  var defineUI5Class = ClassSupport.defineUI5Class;
+  function _initializerDefineProperty(target, property, descriptor, context) { if (!descriptor) return; Object.defineProperty(target, property, { enumerable: descriptor.enumerable, configurable: descriptor.configurable, writable: descriptor.writable, value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 }); }
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+  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); }
+  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
+  function _initializerWarningHelper(descriptor, context) { throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); }
+  let ReuseComponent = (_dec = defineUI5Class("sap.fe.core.ReuseComponent"), _dec2 = property({
+    type: "object"
+  }), _dec3 = event(), _dec(_class = (_class2 = /*#__PURE__*/function (_FPMComponent) {
+    _inheritsLoose(ReuseComponent, _FPMComponent);
+    function ReuseComponent() {
+      var _this;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _FPMComponent.call(this, ...args) || this;
+      _initializerDefineProperty(_this, "override", _descriptor, _assertThisInitialized(_this));
+      _initializerDefineProperty(_this, "initialized", _descriptor2, _assertThisInitialized(_this));
+      _this.hooksApplied = false;
+      return _this;
+    }
+    var _proto = ReuseComponent.prototype;
+    /**
+     * Sets the container of the component.
+     *
+     * This is being called by UI5. We override this method to keep track of the container and to initialize the router.
+     *
+     * @param container The container
+     * @returns The instance of the component
+     */
+    _proto.setContainer = function setContainer(container) {
+      _FPMComponent.prototype.setContainer.call(this, container);
+      this.container = container;
+      const router = this.getRouter();
+      if (router) {
+        // once the container is set, we can initialize the router
+        router.initialize();
+      }
+      return this;
+    };
+    _proto.applyHooks = function applyHooks() {
+      if (this.hooksApplied || !this.container) {
+        return;
+      }
+      const pageController = this.getPageComponent().getRootController();
+      if (!pageController) {
+        return;
+      }
+      for (const controllerExtensionOverrideName in this.override) {
+        const controllerExtensionOverride = this.override[controllerExtensionOverrideName];
+        const pageControllerExtension = pageController[controllerExtensionOverrideName];
+        if (!pageControllerExtension) {
+          Log.error(`The controller extension ${controllerExtensionOverrideName} does not exist in the page controller.`);
+          continue;
+        }
+        for (const hookName in controllerExtensionOverride) {
+          const attachHook = pageControllerExtension[`attach${String(hookName)}`];
+          if (!attachHook) {
+            Log.error(`The hook ${hookName} does not exist in the page controller extension ${controllerExtensionOverrideName}.`);
+            continue;
+          }
+          const handlerFunction = controllerExtensionOverride[hookName];
+          attachHook(handlerFunction);
+          pageController.getView().attachBeforeExit(() => {
+            this.hooksApplied = false;
+            pageControllerExtension[`detach${String(hookName)}`](handlerFunction);
+          });
+        }
+      }
+      this.hooksApplied = true;
+      this.fireEvent("initialized");
+    }
+
+    /**
+     * Creates the content of the component.
+     *
+     * This is being called by UI5. We override this method to implement our own template logic
+     * and to inform UI5 when the root control is being created.
+     *
+     * @returns A promise that resolves with the root control
+     */;
+    _proto.createContent = async function createContent() {
+      this.attachModelContextChange(this.applyHooks.bind(this));
+      return new Promise(resolve => {
+        this.rootControlCreated = resolve;
+      });
+    }
+
+    /**
+     * Sets an aggregation of the component.
+     *
+     * This is being called by UI5. We override this method to know when the rootControl is being set.
+     *
+     * @param aggregationName The name of the aggregation
+     * @param object The object to set
+     * @param suppressInvalidate Whether to suppress invalidation
+     * @returns The instance of the component
+     */;
+    _proto.setAggregation = function setAggregation(aggregationName, object, suppressInvalidate) {
+      if (aggregationName === "rootControl") {
+        const rootControl = object;
+        this.rootControlCreated(rootControl);
+      }
+      return _FPMComponent.prototype.setAggregation.call(this, aggregationName, object, suppressInvalidate);
+    }
+
+    /**
+     * Returns the view name of the reuse component.
+     * This is being called by the template service to create the view.
+     *
+     * @returns The view name
+     */;
+    _proto.getViewName = function getViewName() {
+      var _this$getManifestEntr;
+      const rootViewName = (_this$getManifestEntr = this.getManifestEntry("sap.ui5").rootView) === null || _this$getManifestEntr === void 0 ? void 0 : _this$getManifestEntr.viewName;
+      if (!rootViewName && !this.viewName) {
+        throw new Error("No root view defined in the manifest nor viewName set in the component");
+      }
+      return rootViewName || this.viewName;
+    }
+
+    /**
+     * Returns the page component that owns the reuse component.
+     *
+     * @returns The page component
+     */;
+    _proto.getPageComponent = function getPageComponent() {
+      var _this$container;
+      // the owner of the reuse component is not the page component but the app component.
+      // we rely on the parent of the container to be the owned by the page component
+      // and get the extensionAPI from there. If the parent is not a control, we throw an error
+      const parent = (_this$container = this.container) === null || _this$container === void 0 ? void 0 : _this$container.getParent();
+      if (!parent) {
+        throw new Error("The parent of the reuse component is not yet set. Thus, the page component cannot be retrieved.");
+      }
+      return Component.getOwnerComponentFor(parent);
+    }
+
+    /**
+     * Returns the extension API of the page component that owns the reuse component.
+     *
+     * @returns The extension API
+     */;
+    _proto.getExtensionAPI = function getExtensionAPI() {
+      return this.getPageComponent().getExtensionAPI();
+    };
+    return ReuseComponent;
+  }(FPMComponent), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "override", [_dec2], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  }), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "initialized", [_dec3], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  })), _class2)) || _class);
+  return ReuseComponent;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ReuseComponent","defineUI5Class","property","type","event","hooksApplied","setContainer","container","router","getRouter","initialize","applyHooks","pageController","getPageComponent","getRootController","controllerExtensionOverrideName","override","controllerExtensionOverride","pageControllerExtension","Log","error","hookName","attachHook","String","handlerFunction","getView","attachBeforeExit","fireEvent","createContent","attachModelContextChange","bind","Promise","resolve","rootControlCreated","setAggregation","aggregationName","object","suppressInvalidate","rootControl","getViewName","rootViewName","getManifestEntry","rootView","viewName","Error","parent","getParent","Component","getOwnerComponentFor","getExtensionAPI","FPMComponent"],"sourceRoot":".","sources":["ReuseComponent.ts"],"sourcesContent":["import Log from \"sap/base/Log\";\nimport { defineUI5Class, event, property } from \"sap/fe/base/ClassSupport\";\nimport type ExtensionAPI from \"sap/fe/core/ExtensionAPI\";\nimport type TemplateComponent from \"sap/fe/core/TemplateComponent\";\nimport FPMComponent from \"sap/fe/core/fpm/Component\";\nimport type ManagedObject from \"sap/ui/base/ManagedObject\";\nimport Component from \"sap/ui/core/Component\";\nimport type ComponentContainer from \"sap/ui/core/ComponentContainer\";\nimport type Control from \"sap/ui/core/Control\";\n\n@defineUI5Class(\"sap.fe.core.ReuseComponent\")\nclass ReuseComponent extends FPMComponent {\n\t@property({ type: \"object\" })\n\toverride?: Record<string, object>;\n\n\t// event that is fired once the component is initialized\n\t@event()\n\tinitialized!: Function;\n\n\tcontainer!: ComponentContainer;\n\n\thooksApplied = false;\n\n\trootControlCreated!: (control: Control) => void;\n\n\t/**\n\t * Sets the container of the component.\n\t *\n\t * This is being called by UI5. We override this method to keep track of the container and to initialize the router.\n\t *\n\t * @param container The container\n\t * @returns The instance of the component\n\t */\n\tsetContainer(container: ComponentContainer): this {\n\t\tsuper.setContainer(container);\n\t\tthis.container = container;\n\n\t\tconst router = this.getRouter();\n\t\tif (router) {\n\t\t\t// once the container is set, we can initialize the router\n\t\t\trouter.initialize();\n\t\t}\n\n\t\treturn this;\n\t}\n\n\tapplyHooks(): void {\n\t\ttype FunctionMap = {\n\t\t\t[key: string]: Function;\n\t\t};\n\t\ttype DeepFunctionMap = {\n\t\t\t[key: string]: FunctionMap;\n\t\t};\n\n\t\tif (this.hooksApplied || !this.container) {\n\t\t\treturn;\n\t\t}\n\t\tconst pageController = this.getPageComponent().getRootController();\n\n\t\tif (!pageController) {\n\t\t\treturn;\n\t\t}\n\n\t\tfor (const controllerExtensionOverrideName in this.override) {\n\t\t\tconst controllerExtensionOverride = this.override[controllerExtensionOverrideName];\n\t\t\tconst pageControllerExtension = (pageController as unknown as DeepFunctionMap)[controllerExtensionOverrideName];\n\n\t\t\tif (!pageControllerExtension) {\n\t\t\t\tLog.error(`The controller extension ${controllerExtensionOverrideName} does not exist in the page controller.`);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tfor (const hookName in controllerExtensionOverride) {\n\t\t\t\tconst attachHook = pageControllerExtension[`attach${String(hookName)}`];\n\t\t\t\tif (!attachHook) {\n\t\t\t\t\tLog.error(`The hook ${hookName} does not exist in the page controller extension ${controllerExtensionOverrideName}.`);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst handlerFunction = (controllerExtensionOverride as FunctionMap)[hookName];\n\n\t\t\t\tattachHook(handlerFunction);\n\t\t\t\tpageController.getView().attachBeforeExit(() => {\n\t\t\t\t\tthis.hooksApplied = false;\n\t\t\t\t\tpageControllerExtension[`detach${String(hookName)}`](handlerFunction);\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\tthis.hooksApplied = true;\n\t\tthis.fireEvent(\"initialized\");\n\t}\n\n\t/**\n\t * Creates the content of the component.\n\t *\n\t * This is being called by UI5. We override this method to implement our own template logic\n\t * and to inform UI5 when the root control is being created.\n\t *\n\t * @returns A promise that resolves with the root control\n\t */\n\tasync createContent(): Promise<Control> {\n\t\tthis.attachModelContextChange(this.applyHooks.bind(this));\n\n\t\treturn new Promise((resolve) => {\n\t\t\tthis.rootControlCreated = resolve;\n\t\t});\n\t}\n\n\t/**\n\t * Sets an aggregation of the component.\n\t *\n\t * This is being called by UI5. We override this method to know when the rootControl is being set.\n\t *\n\t * @param aggregationName The name of the aggregation\n\t * @param object The object to set\n\t * @param suppressInvalidate Whether to suppress invalidation\n\t * @returns The instance of the component\n\t */\n\tsetAggregation(aggregationName: string, object: ManagedObject, suppressInvalidate?: boolean): this {\n\t\tif (aggregationName === \"rootControl\") {\n\t\t\tconst rootControl = object as Control;\n\t\t\tthis.rootControlCreated(rootControl);\n\t\t}\n\t\treturn super.setAggregation(aggregationName, object, suppressInvalidate);\n\t}\n\n\t/**\n\t * Returns the view name of the reuse component.\n\t * This is being called by the template service to create the view.\n\t *\n\t * @returns The view name\n\t */\n\tgetViewName(): string {\n\t\tconst rootViewName = this.getManifestEntry(\"sap.ui5\").rootView?.viewName;\n\t\tif (!rootViewName && !this.viewName) {\n\t\t\tthrow new Error(\"No root view defined in the manifest nor viewName set in the component\");\n\t\t}\n\t\treturn rootViewName || this.viewName;\n\t}\n\n\t/**\n\t * Returns the page component that owns the reuse component.\n\t *\n\t * @returns The page component\n\t */\n\tgetPageComponent(): TemplateComponent {\n\t\t// the owner of the reuse component is not the page component but the app component.\n\t\t// we rely on the parent of the container to be the owned by the page component\n\t\t// and get the extensionAPI from there. If the parent is not a control, we throw an error\n\t\tconst parent = this.container?.getParent();\n\t\tif (!parent) {\n\t\t\tthrow new Error(\"The parent of the reuse component is not yet set. Thus, the page component cannot be retrieved.\");\n\t\t}\n\t\treturn Component.getOwnerComponentFor(parent) as TemplateComponent;\n\t}\n\n\t/**\n\t * Returns the extension API of the page component that owns the reuse component.\n\t *\n\t * @returns The extension API\n\t */\n\tgetExtensionAPI(): ExtensionAPI {\n\t\treturn this.getPageComponent().getExtensionAPI();\n\t}\n}\n\nexport default ReuseComponent;\n"],"mappings":"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"}

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

@@ -0,0 +1,165 @@
+import Log from "sap/base/Log";
+import { defineUI5Class, event, property } from "sap/fe/base/ClassSupport";
+import type ExtensionAPI from "sap/fe/core/ExtensionAPI";
+import type TemplateComponent from "sap/fe/core/TemplateComponent";
+import FPMComponent from "sap/fe/core/fpm/Component";
+import type ManagedObject from "sap/ui/base/ManagedObject";
+import Component from "sap/ui/core/Component";
+import type ComponentContainer from "sap/ui/core/ComponentContainer";
+import type Control from "sap/ui/core/Control";
+
+@defineUI5Class("sap.fe.core.ReuseComponent")
+class ReuseComponent extends FPMComponent {
+	@property({ type: "object" })
+	override?: Record<string, object>;
+
+	// event that is fired once the component is initialized
+	@event()
+	initialized!: Function;
+
+	container!: ComponentContainer;
+
+	hooksApplied = false;
+
+	rootControlCreated!: (control: Control) => void;
+
+	/**
+	 * Sets the container of the component.
+	 *
+	 * This is being called by UI5. We override this method to keep track of the container and to initialize the router.
+	 *
+	 * @param container The container
+	 * @returns The instance of the component
+	 */
+	setContainer(container: ComponentContainer): this {
+		super.setContainer(container);
+		this.container = container;
+
+		const router = this.getRouter();
+		if (router) {
+			// once the container is set, we can initialize the router
+			router.initialize();
+		}
+
+		return this;
+	}
+
+	applyHooks(): void {
+		type FunctionMap = {
+			[key: string]: Function;
+		};
+		type DeepFunctionMap = {
+			[key: string]: FunctionMap;
+		};
+
+		if (this.hooksApplied || !this.container) {
+			return;
+		}
+		const pageController = this.getPageComponent().getRootController();
+
+		if (!pageController) {
+			return;
+		}
+
+		for (const controllerExtensionOverrideName in this.override) {
+			const controllerExtensionOverride = this.override[controllerExtensionOverrideName];
+			const pageControllerExtension = (pageController as unknown as DeepFunctionMap)[controllerExtensionOverrideName];
+
+			if (!pageControllerExtension) {
+				Log.error(`The controller extension ${controllerExtensionOverrideName} does not exist in the page controller.`);
+				continue;
+			}
+			for (const hookName in controllerExtensionOverride) {
+				const attachHook = pageControllerExtension[`attach${String(hookName)}`];
+				if (!attachHook) {
+					Log.error(`The hook ${hookName} does not exist in the page controller extension ${controllerExtensionOverrideName}.`);
+					continue;
+				}
+				const handlerFunction = (controllerExtensionOverride as FunctionMap)[hookName];
+
+				attachHook(handlerFunction);
+				pageController.getView().attachBeforeExit(() => {
+					this.hooksApplied = false;
+					pageControllerExtension[`detach${String(hookName)}`](handlerFunction);
+				});
+			}
+		}
+		this.hooksApplied = true;
+		this.fireEvent("initialized");
+	}
+
+	/**
+	 * Creates the content of the component.
+	 *
+	 * This is being called by UI5. We override this method to implement our own template logic
+	 * and to inform UI5 when the root control is being created.
+	 *
+	 * @returns A promise that resolves with the root control
+	 */
+	async createContent(): Promise<Control> {
+		this.attachModelContextChange(this.applyHooks.bind(this));
+
+		return new Promise((resolve) => {
+			this.rootControlCreated = resolve;
+		});
+	}
+
+	/**
+	 * Sets an aggregation of the component.
+	 *
+	 * This is being called by UI5. We override this method to know when the rootControl is being set.
+	 *
+	 * @param aggregationName The name of the aggregation
+	 * @param object The object to set
+	 * @param suppressInvalidate Whether to suppress invalidation
+	 * @returns The instance of the component
+	 */
+	setAggregation(aggregationName: string, object: ManagedObject, suppressInvalidate?: boolean): this {
+		if (aggregationName === "rootControl") {
+			const rootControl = object as Control;
+			this.rootControlCreated(rootControl);
+		}
+		return super.setAggregation(aggregationName, object, suppressInvalidate);
+	}
+
+	/**
+	 * Returns the view name of the reuse component.
+	 * This is being called by the template service to create the view.
+	 *
+	 * @returns The view name
+	 */
+	getViewName(): string {
+		const rootViewName = this.getManifestEntry("sap.ui5").rootView?.viewName;
+		if (!rootViewName && !this.viewName) {
+			throw new Error("No root view defined in the manifest nor viewName set in the component");
+		}
+		return rootViewName || this.viewName;
+	}
+
+	/**
+	 * Returns the page component that owns the reuse component.
+	 *
+	 * @returns The page component
+	 */
+	getPageComponent(): TemplateComponent {
+		// the owner of the reuse component is not the page component but the app component.
+		// we rely on the parent of the container to be the owned by the page component
+		// and get the extensionAPI from there. If the parent is not a control, we throw an error
+		const parent = this.container?.getParent();
+		if (!parent) {
+			throw new Error("The parent of the reuse component is not yet set. Thus, the page component cannot be retrieved.");
+		}
+		return Component.getOwnerComponentFor(parent) as TemplateComponent;
+	}
+
+	/**
+	 * Returns the extension API of the page component that owns the reuse component.
+	 *
+	 * @returns The extension API
+	 */
+	getExtensionAPI(): ExtensionAPI {
+		return this.getPageComponent().getExtensionAPI();
+	}
+}
+
+export default ReuseComponent;

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

@@ -2,7 +2,7 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2024 SAP SE. All rights reserved
  */
-sap.ui.define(["sap/fe/core/CommonUtils", "sap/fe/core/helpers/ClassSupport", "sap/ui/core/UIComponent"], function (CommonUtils, ClassSupport, UIComponent) {
+sap.ui.define(["sap/fe/base/ClassSupport", "sap/fe/core/CommonUtils", "sap/ui/core/UIComponent"], function (ClassSupport, CommonUtils, UIComponent) {
   "use strict";
 
   var _dec, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec10, _dec11, _dec12, _dec13, _dec14, _dec15, _dec16, _dec17, _dec18, _class, _class2, _descriptor, _descriptor2, _descriptor3, _descriptor4, _descriptor5, _descriptor6, _descriptor7, _descriptor8, _descriptor9, _descriptor10, _descriptor11, _descriptor12, _descriptor13, _descriptor14, _descriptor15, _descriptor16, _descriptor17;
@@ -238,4 +238,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","getExtensionComponent","setRootController","controller","_rootController","getRootController","rootControl","getRootControl","rootController","getController","onPageReady","mParameters","getNavigationConfiguration","sTargetPath","mNavigation","navigation","getViewData","mProperties","getMetadata","getAllProperties","oViewData","Object","keys","reduce","mViewData","sPropertyName","get","preprocessorContext","fclEnabled","_isFclEnabled","_getPageTitleInformation","getExtensionAPI","UIComponent"],"sourceRoot":".","sources":["TemplateComponent.ts"],"sourcesContent":["import type { ConvertedMetadata } from \"@sap-ux/vocabularies-types\";\nimport type AppComponent from \"sap/fe/core/AppComponent\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport type ExtensionAPI from \"sap/fe/core/ExtensionAPI\";\nimport type PageController from \"sap/fe/core/PageController\";\nimport type ConverterContext from \"sap/fe/core/converters/ConverterContext\";\nimport type { NavigationTargetConfiguration } from \"sap/fe/core/converters/ManifestSettings\";\nimport { defineUI5Class, event, implementInterface, property } from \"sap/fe/core/helpers/ClassSupport\";\nimport type { TitleInformation } from \"sap/fe/core/rootView/RootViewBaseController\";\nimport type ComponentContainer from \"sap/ui/core/ComponentContainer\";\nimport UIComponent from \"sap/ui/core/UIComponent\";\nimport type { IAsyncContentCreation } from \"sap/ui/core/library\";\nimport type View from \"sap/ui/core/mvc/View\";\nimport type BaseContext from \"sap/ui/model/Context\";\nimport type Model from \"sap/ui/model/Model\";\nimport type JSONModel from \"sap/ui/model/json/JSONModel\";\nimport type Context from \"sap/ui/model/odata/v4/Context\";\nimport type ODataListBinding from \"sap/ui/model/odata/v4/ODataListBinding\";\nimport type ODataModel from \"sap/ui/model/odata/v4/ODataModel\";\n\nexport type NavigationConfiguration = {\n\tdetail: {\n\t\troute: string;\n\t\tparameters: unknown;\n\t\toutbound?: string;\n\t\toutboundDetail?: NavigationTargetConfiguration[\"outboundDetail\"];\n\t};\n\tcreate: {\n\t\troute: string;\n\t\tparameters: unknown;\n\t\toutbound?: string;\n\t\toutboundDetail?: NavigationTargetConfiguration[\"outboundDetail\"];\n\t};\n};\n\nexport type XMLPreprocessorContext = {\n\tbindingContexts: Record<string, BaseContext | null>;\n\tmodels: Record<string, Model>;\n\tfullContextPath: string;\n\tgetConvertedMetadata: () => ConvertedMetadata;\n\tappComponent: AppComponent;\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@property({ type: \"object\" })\n\tpreprocessorContext?: XMLPreprocessorContext;\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@property({ type: \"string\" })\n\tviewName?: string;\n\n\t@property({ type: \"string\" })\n\t_jsxViewName = \"\";\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\tprivate _rootController?: PageController;\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(): void {\n\t\tthis.oAppComponent = CommonUtils.getAppComponent(this);\n\t\tsuper.init();\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\tgetAppComponent(): AppComponent {\n\t\treturn this.oAppComponent;\n\t}\n\n\tsetRootController(controller: PageController): void {\n\t\tthis._rootController = controller;\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} else {\n\t\t\trootController = this._rootController;\n\t\t}\n\t\treturn rootController;\n\t}\n\n\tonPageReady(mParameters: unknown): void {\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(): Record<string, unknown> {\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\t\tdelete oViewData.preprocessorContext;\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(): TitleInformation {\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 {} as TitleInformation;\n\t\t}\n\t}\n\n\tgetExtensionAPI(): ExtensionAPI {\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?(\n\t\tsPath: string,\n\t\toListBinding: ODataListBinding | undefined,\n\t\tparentContext: Context | undefined,\n\t\tdata: object | undefined,\n\t\tbActionCreate: boolean\n\t): void;\n\tisOpenInEditMode(): boolean;\n\tgetRootControl(): { getController(): PageController } & View;\n\textendPageDefinition?(pageDefinition: {}, converterContext?: ConverterContext): {};\n\tgetModel(): ODataModel;\n\tgetModel(modelName: \"_pageModel\"): JSONModel;\n\tgetModel(modelName: string): Model | undefined;\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","getExtensionComponent","setRootController","controller","_rootController","getRootController","rootControl","getRootControl","rootController","getController","onPageReady","mParameters","getNavigationConfiguration","sTargetPath","mNavigation","navigation","getViewData","mProperties","getMetadata","getAllProperties","oViewData","Object","keys","reduce","mViewData","sPropertyName","get","preprocessorContext","fclEnabled","_isFclEnabled","_getPageTitleInformation","getExtensionAPI","UIComponent"],"sourceRoot":".","sources":["TemplateComponent.ts"],"sourcesContent":["import type { ConvertedMetadata } from \"@sap-ux/vocabularies-types\";\nimport { defineUI5Class, event, implementInterface, property } from \"sap/fe/base/ClassSupport\";\nimport type AppComponent from \"sap/fe/core/AppComponent\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport type ExtensionAPI from \"sap/fe/core/ExtensionAPI\";\nimport type PageController from \"sap/fe/core/PageController\";\nimport type ConverterContext from \"sap/fe/core/converters/ConverterContext\";\nimport type { NavigationTargetConfiguration } from \"sap/fe/core/converters/ManifestSettings\";\nimport type { TitleInformation } from \"sap/fe/core/rootView/RootViewBaseController\";\nimport type ComponentContainer from \"sap/ui/core/ComponentContainer\";\nimport UIComponent from \"sap/ui/core/UIComponent\";\nimport type { IAsyncContentCreation } from \"sap/ui/core/library\";\nimport type View from \"sap/ui/core/mvc/View\";\nimport type BaseContext from \"sap/ui/model/Context\";\nimport type Model from \"sap/ui/model/Model\";\nimport type JSONModel from \"sap/ui/model/json/JSONModel\";\nimport type Context from \"sap/ui/model/odata/v4/Context\";\nimport type ODataListBinding from \"sap/ui/model/odata/v4/ODataListBinding\";\nimport type ODataModel from \"sap/ui/model/odata/v4/ODataModel\";\n\nexport type NavigationConfiguration = {\n\tdetail: {\n\t\troute: string;\n\t\tparameters: unknown;\n\t\toutbound?: string;\n\t\toutboundDetail?: NavigationTargetConfiguration[\"outboundDetail\"];\n\t};\n\tcreate: {\n\t\troute: string;\n\t\tparameters: unknown;\n\t\toutbound?: string;\n\t\toutboundDetail?: NavigationTargetConfiguration[\"outboundDetail\"];\n\t};\n};\n\nexport type XMLPreprocessorContext = {\n\tbindingContexts: Record<string, BaseContext | null>;\n\tmodels: Record<string, Model>;\n\tfullContextPath: string;\n\tgetConvertedMetadata: () => ConvertedMetadata;\n\tappComponent: AppComponent;\n\tviewId: string;\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@property({ type: \"object\" })\n\tpreprocessorContext?: XMLPreprocessorContext;\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@property({ type: \"string\" })\n\tviewName?: string;\n\n\t@property({ type: \"string\" })\n\t_jsxViewName = \"\";\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\tprivate _rootController?: PageController;\n\n\t// The id of a fragment being processed, it will take priority in the ID generation\n\tprivate _temporaryFragmentId?: string;\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(): void {\n\t\tthis.oAppComponent = CommonUtils.getAppComponent(this);\n\t\tsuper.init();\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\tgetAppComponent(): AppComponent {\n\t\treturn this.oAppComponent;\n\t}\n\n\tsetRootController(controller: PageController): void {\n\t\tthis._rootController = controller;\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} else {\n\t\t\trootController = this._rootController;\n\t\t}\n\t\treturn rootController;\n\t}\n\n\tonPageReady(mParameters: unknown): void {\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(): Record<string, unknown> {\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\t\tdelete oViewData.preprocessorContext;\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(): TitleInformation {\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 {} as TitleInformation;\n\t\t}\n\t}\n\n\tgetExtensionAPI(): ExtensionAPI {\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?(\n\t\tsPath: string,\n\t\toListBinding: ODataListBinding | undefined,\n\t\tparentContext: Context | undefined,\n\t\tdata: object | undefined,\n\t\tbActionCreate: boolean\n\t): void;\n\tisOpenInEditMode(): boolean;\n\tgetRootControl(): { getController(): PageController } & View;\n\textendPageDefinition?(pageDefinition: {}, converterContext?: ConverterContext): {};\n\tgetModel(): ODataModel;\n\tgetModel(modelName: \"_pageModel\"): JSONModel;\n\tgetModel(modelName: string): Model | undefined;\n}\nexport default TemplateComponent;\n"],"mappings":"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"}

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

@@ -1,11 +1,11 @@
 import type { ConvertedMetadata } from "@sap-ux/vocabularies-types";
+import { defineUI5Class, event, implementInterface, property } from "sap/fe/base/ClassSupport";
 import type AppComponent from "sap/fe/core/AppComponent";
 import CommonUtils from "sap/fe/core/CommonUtils";
 import type ExtensionAPI from "sap/fe/core/ExtensionAPI";
 import type PageController from "sap/fe/core/PageController";
 import type ConverterContext from "sap/fe/core/converters/ConverterContext";
 import type { NavigationTargetConfiguration } from "sap/fe/core/converters/ManifestSettings";
-import { defineUI5Class, event, implementInterface, property } from "sap/fe/core/helpers/ClassSupport";
 import type { TitleInformation } from "sap/fe/core/rootView/RootViewBaseController";
 import type ComponentContainer from "sap/ui/core/ComponentContainer";
 import UIComponent from "sap/ui/core/UIComponent";
@@ -39,6 +39,7 @@ export type XMLPreprocessorContext = {
 	fullContextPath: string;
 	getConvertedMetadata: () => ConvertedMetadata;
 	appComponent: AppComponent;
+	viewId: string;
 };
 
 @defineUI5Class("sap.fe.core.TemplateComponent")
@@ -127,6 +128,9 @@ class TemplateComponent extends UIComponent implements IAsyncContentCreation {
 
 	private _rootController?: PageController;
 
+	// The id of a fragment being processed, it will take priority in the ID generation
+	private _temporaryFragmentId?: string;
+
 	setContainer(oContainer: ComponentContainer): this {
 		super.setContainer(oContainer);
 		this.fireEvent("containerDefined", { container: oContainer });

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

@@ -2,7 +2,7 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2024 SAP SE. All rights reserved
  */
-sap.ui.define(["sap/fe/core/helpers/ClassSupport", "sap/ui/base/Object", "sap/ui/model/json/JSONModel"], function (ClassSupport, BaseObject, JSONModel) {
+sap.ui.define(["sap/fe/base/ClassSupport", "sap/ui/base/Object", "sap/ui/model/json/JSONModel"], function (ClassSupport, BaseObject, JSONModel) {
   "use strict";
 
   var _dec, _class;
@@ -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

@@ -1,4 +1,4 @@
-import { defineUI5Class } from "sap/fe/core/helpers/ClassSupport";
+import { defineUI5Class } from "sap/fe/base/ClassSupport";
 import BaseObject from "sap/ui/base/Object";
 import type Context from "sap/ui/model/Context";
 import JSONModel from "sap/ui/model/json/JSONModel";