@sapui5/sap.fe.core 1.92.0 → 1.93.3

package/src/sap/fe/core/controllerextensions/KPIManagement.ts

@@ -0,0 +1,399 @@
+import { ControllerExtension } from "sap/ui/core/mvc";
+import { ControllerExtensionMetadata } from "sap/fe/core/controllerextensions";
+import { UI5Class, Override } from "../helpers/ClassSupport";
+import { JSONModel } from "sap/ui/model/json";
+import { Log } from "sap/base";
+import { KPIDefinition } from "sap/fe/core/converters/controls/Common/KPI";
+import { CommonUtils } from "sap/fe/core";
+import { Context } from "sap/ui/model/odata/v4";
+import { MessageType } from "sap/fe/core/formatters/TableFormatterTypes";
+import { FilterDefinition } from "sap/fe/core/converters/helpers/SelectionVariantHelper";
+import { NumberFormat } from "sap/ui/core/format";
+import { Locale } from "sap/ui/core";
+import { Filter, FilterOperator } from "sap/ui/model";
+
+/**
+ * Function to calculate a message state from a criticality value.
+ *
+ * @param {number|string} criticalityValue The criticality values.
+ * @returns {MessageType} Returns the corresponding MessageType
+ */
+function messageTypeFromCriticality(criticalityValue: number | string): MessageType {
+	let criticalityProperty: MessageType;
+
+	switch (criticalityValue) {
+		case 1:
+			criticalityProperty = MessageType.Error;
+			break;
+		case 2:
+			criticalityProperty = MessageType.Warning;
+			break;
+		case 3:
+			criticalityProperty = MessageType.Success;
+			break;
+		case 5:
+			criticalityProperty = MessageType.Information;
+			break;
+		default:
+			criticalityProperty = MessageType.None;
+	}
+
+	return criticalityProperty;
+}
+
+/**
+ * Function to calculate the message state for a criticality calculation of type 'Target'.
+ *
+ * @param {number} kpiValue The value of the KPI to be tested against.
+ * @param {number[]} aThresholds Thresholds to be used [DeviationRangeLowValue,ToleranceRangeLowValue,AcceptanceRangeLowValue,AcceptanceRangeHighValue,ToleranceRangeHighValue,DeviationRangeHighValue].
+ * @returns {MessageType} Returns the corresponding MessageType
+ */
+function messageTypeFromTargetCalculation(kpiValue: number, aThresholds: (number | undefined | null)[]): MessageType {
+	let criticalityProperty: MessageType;
+
+	if (aThresholds[0] !== undefined && aThresholds[0] !== null && kpiValue < aThresholds[0]) {
+		criticalityProperty = MessageType.Error;
+	} else if (aThresholds[1] !== undefined && aThresholds[1] !== null && kpiValue < aThresholds[1]) {
+		criticalityProperty = MessageType.Warning;
+	} else if (aThresholds[2] !== undefined && aThresholds[2] !== null && kpiValue < aThresholds[2]) {
+		criticalityProperty = MessageType.None;
+	} else if (aThresholds[5] !== undefined && aThresholds[5] !== null && kpiValue > aThresholds[5]) {
+		criticalityProperty = MessageType.Error;
+	} else if (aThresholds[4] !== undefined && aThresholds[4] !== null && kpiValue > aThresholds[4]) {
+		criticalityProperty = MessageType.Warning;
+	} else if (aThresholds[3] !== undefined && aThresholds[3] !== null && kpiValue > aThresholds[3]) {
+		criticalityProperty = MessageType.None;
+	} else {
+		criticalityProperty = MessageType.Success;
+	}
+
+	return criticalityProperty;
+}
+
+/**
+ * Function to calculate the message state for a criticality calculation of type 'Minimize'.
+ *
+ * @param {number} kpiValue The value of the KPI to be tested against.
+ * @param {number[]} aThresholds Thresholds to be used [AcceptanceRangeHighValue,ToleranceRangeHighValue,DeviationRangeHighValue].
+ * @returns {MessageType} Returns the corresponding MessageType
+ */
+function messageTypeFromMinimizeCalculation(kpiValue: number, aThresholds: (number | undefined | null)[]): MessageType {
+	let criticalityProperty: MessageType;
+
+	if (aThresholds[2] !== undefined && aThresholds[2] !== null && kpiValue > aThresholds[2]) {
+		criticalityProperty = MessageType.Error;
+	} else if (aThresholds[1] !== undefined && aThresholds[1] !== null && kpiValue > aThresholds[1]) {
+		criticalityProperty = MessageType.Warning;
+	} else if (aThresholds[0] !== undefined && aThresholds[0] !== null && kpiValue > aThresholds[0]) {
+		criticalityProperty = MessageType.None;
+	} else {
+		criticalityProperty = MessageType.Success;
+	}
+
+	return criticalityProperty;
+}
+
+/**
+ * Function to calculate the message state for a criticality calculation of type 'Maximize'.
+ *
+ * @param {number} kpiValue The value of the KPI to be tested against.
+ * @param {number[]} aThresholds Thresholds to be used [DeviationRangeLowValue,ToleranceRangeLowValue,AcceptanceRangeLowValue].
+ * @returns {MessageType} Returns the corresponding MessageType
+ */
+function messageTypeFromMaximizeCalculation(kpiValue: number, aThresholds: (number | undefined | null)[]): MessageType {
+	let criticalityProperty: MessageType;
+
+	if (aThresholds[0] !== undefined && aThresholds[0] !== null && kpiValue < aThresholds[0]) {
+		criticalityProperty = MessageType.Error;
+	} else if (aThresholds[1] !== undefined && aThresholds[1] !== null && kpiValue < aThresholds[1]) {
+		criticalityProperty = MessageType.Warning;
+	} else if (aThresholds[2] !== undefined && aThresholds[2] !== null && kpiValue < aThresholds[2]) {
+		criticalityProperty = MessageType.None;
+	} else {
+		criticalityProperty = MessageType.Success;
+	}
+
+	return criticalityProperty;
+}
+
+/**
+ * Creates a sap.ui.model.Filter from a filter definition.
+ *
+ * @param filterDefinition The filter definition
+ * @returns Returns a sap.ui.model.Filter from the definition, or undefined if the definition is empty (no ranges)
+ */
+export function createFilterFromDefinition(filterDefinition: FilterDefinition): Filter | undefined {
+	if (filterDefinition.ranges.length === 0) {
+		return undefined;
+	} else if (filterDefinition.ranges.length === 1) {
+		return new Filter(
+			filterDefinition.propertyPath,
+			filterDefinition.ranges[0].operator as FilterOperator,
+			filterDefinition.ranges[0].rangeLow,
+			filterDefinition.ranges[0].rangeHigh
+		);
+	} else {
+		const aRangeFilters = filterDefinition.ranges.map(range => {
+			return new Filter(filterDefinition.propertyPath, range.operator as FilterOperator, range.rangeLow, range.rangeHigh);
+		});
+		return new Filter({
+			filters: aRangeFilters,
+			and: false
+		});
+	}
+}
+
+/**
+ * @class A controller extension for managing KPI in an AnalyticalListPage
+ *
+ * @name sap.fe.core.controllerextensions.KPIManagement
+ * @hideconstructor
+ *
+ * @private
+ * @since 1.93.0
+ */
+@UI5Class("sap.fe.core.controllerextensions.KPIManagement", ControllerExtensionMetadata)
+class KPIManagementControllerExtension extends ControllerExtension {
+	protected aKPIDefinitions?: KPIDefinition[];
+	protected oAppComponent!: any;
+
+	@Override()
+	public onInit(): void {
+		this.aKPIDefinitions = this.getKPIData();
+
+		if (this.aKPIDefinitions && this.aKPIDefinitions.length) {
+			const oView = this.getView();
+			this.oAppComponent = CommonUtils.getAppComponent(oView);
+
+			// Create a JSON model to store KPI data
+			const oKPIModel = new JSONModel();
+			oView.setModel(oKPIModel, "kpiModel");
+
+			this.aKPIDefinitions.forEach(kpiDefinition => {
+				// Create the manifest for the KPI card and store it in the KPI model
+				const oCardManifest = {
+					"sap.app": {
+						id: "sap.fe",
+						type: "card"
+					},
+					"sap.ui": {
+						technology: "UI5"
+					},
+					"sap.card": {
+						type: "Analytical",
+						data: {
+							json: {}
+						},
+						header: {
+							type: "Numeric",
+							mainIndicator: {
+								number: "{mainValue}",
+								unit: "{mainUnit}"
+							},
+							title: "{cardTitle}"
+						},
+						content: {
+							plotArea: {
+								"dataLabel": {
+									"visible": false
+								},
+								"categoryAxisText": {
+									"visible": false
+								},
+								"valueAxisText": {
+									"visible": false
+								}
+							},
+							title: {
+								text: "{chartTitle}",
+								visible: true,
+								alignment: "Left"
+							},
+							measureAxis: "valueAxis",
+							dimensionAxis: "categoryAxis",
+							data: {
+								path: "/chartData"
+							}
+						}
+					}
+				};
+
+				oKPIModel.setProperty("/" + kpiDefinition.id, {
+					manifest: oCardManifest
+				});
+
+				// Load tag data for the KPI
+				this.loadKPITagData(kpiDefinition).catch(function(err: any) {
+					Log.error(err);
+				});
+			});
+		}
+	}
+
+	@Override()
+	public onExit(): void {
+		const oKPIModel = this.getView().getModel("kpiModel") as JSONModel;
+
+		if (oKPIModel) {
+			oKPIModel.destroy();
+		}
+	}
+
+	private getKPIData(): KPIDefinition[] | undefined {
+		const oView = this.getView(),
+			sCustomData = oView.getContent()[0].data("KPIData");
+
+		if (sCustomData) {
+			const vData = typeof sCustomData === "string" ? JSON.parse(sCustomData) : sCustomData;
+			if ("customData" in vData) {
+				return vData["customData"];
+			} else {
+				return vData;
+			}
+		} else {
+			return undefined;
+		}
+	}
+
+	/**
+	 * Loads tag data for a KPI.
+	 *
+	 * @param {KPIDefinition} kpiDefinition The definition of the KPI.
+	 * @returns {Promise} Returns the Promise that is resolved when data is loaded.
+	 */
+	protected loadKPITagData(kpiDefinition: KPIDefinition): any {
+		const oModel = this.oAppComponent.getModel();
+		const oKPIModel = this.getView().getModel("kpiModel") as JSONModel;
+		const oListBinding = oModel.bindList("/" + kpiDefinition.entitySet);
+		const oAggregate: Record<string, { unit?: string }> = {};
+
+		// Main value + currency/unit
+		if (kpiDefinition.datapoint.unit?.isPath) {
+			oAggregate[kpiDefinition.datapoint.propertyPath] = { unit: kpiDefinition.datapoint.unit.value };
+		} else {
+			oAggregate[kpiDefinition.datapoint.propertyPath] = {};
+		}
+
+		// Property for criticality
+		if (kpiDefinition.datapoint.criticalityPath) {
+			oAggregate[kpiDefinition.datapoint.criticalityPath] = {};
+		}
+		oListBinding.setAggregation({ aggregate: oAggregate });
+
+		// Manage SelectionVariant filters
+		if (kpiDefinition.selectionVariantFilterDefinitions?.length) {
+			const aFilters = kpiDefinition.selectionVariantFilterDefinitions.map(createFilterFromDefinition);
+			oListBinding.filter(aFilters);
+		}
+
+		return oListBinding.requestContexts(0, 1).then((aContexts: Context[]) => {
+			if (aContexts.length) {
+				const currentLocale = new Locale(
+					sap.ui
+						.getCore()
+						.getConfiguration()
+						.getLanguage()
+				);
+				const rawUnit = kpiDefinition.datapoint.unit?.isPath
+					? aContexts[0].getProperty(kpiDefinition.datapoint.unit.value)
+					: kpiDefinition.datapoint.unit?.value;
+
+				if (kpiDefinition.datapoint.unit && !rawUnit) {
+					// A unit/currency is defined, but its value is undefined --> multi-unit situation
+					oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainValue", "*");
+					oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainValueUnscaled", "*");
+					oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainUnit", undefined);
+					oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainCriticality", MessageType.None);
+				} else {
+					const isPercentage = kpiDefinition.datapoint.unit?.isCurrency === false && rawUnit === "%";
+
+					// Main KPI value
+					const rawValue = Number.parseFloat(aContexts[0].getProperty(kpiDefinition.datapoint.propertyPath));
+					const kpiValue = NumberFormat.getFloatInstance(
+						{
+							style: isPercentage ? undefined : "short",
+							minFractionDigits: 0,
+							maxFractionDigits: 1,
+							showScale: !isPercentage
+						},
+						currentLocale
+					).format(rawValue);
+					oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainValue", kpiValue);
+					const kpiValueUnscaled = NumberFormat.getFloatInstance(
+						{
+							maxFractionDigits: 2,
+							showScale: false,
+							groupingEnabled: true
+						},
+						currentLocale
+					).format(rawValue);
+					oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainValueUnscaled", kpiValueUnscaled);
+
+					// Unit or currency
+					if (kpiDefinition.datapoint.unit && rawUnit) {
+						if (kpiDefinition.datapoint.unit.isCurrency) {
+							oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainUnit", rawUnit);
+						} else {
+							// In case of unit of measure, we have to format it properly
+							const kpiUnit = NumberFormat.getUnitInstance({ showNumber: false }, currentLocale).format(rawValue, rawUnit);
+							oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainUnit", kpiUnit);
+						}
+					}
+
+					// Criticality
+					if (kpiDefinition.datapoint.criticalityValue) {
+						// Criticality is a fixed value
+						oKPIModel.setProperty(
+							"/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainCriticality",
+							kpiDefinition.datapoint.criticalityValue
+						);
+					} else if (kpiDefinition.datapoint.criticalityPath) {
+						// Criticality comes from another property (via a path)
+						const criticalityValue = messageTypeFromCriticality(
+							aContexts[0].getProperty(kpiDefinition.datapoint.criticalityPath)
+						);
+						oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainCriticality", criticalityValue);
+					} else if (
+						kpiDefinition.datapoint.criticalityCalculationThresholds &&
+						kpiDefinition.datapoint.criticalityCalculationMode
+					) {
+						// Criticality calculation
+						let calculatedCriticality: MessageType;
+						switch (kpiDefinition.datapoint.criticalityCalculationMode) {
+							case "UI.ImprovementDirectionType/Target":
+								calculatedCriticality = messageTypeFromTargetCalculation(
+									rawValue,
+									kpiDefinition.datapoint.criticalityCalculationThresholds
+								);
+								break;
+
+							case "UI.ImprovementDirectionType/Minimize":
+								calculatedCriticality = messageTypeFromMinimizeCalculation(
+									rawValue,
+									kpiDefinition.datapoint.criticalityCalculationThresholds
+								);
+								break;
+
+							case "UI.ImprovementDirectionType/Maximize":
+							default:
+								calculatedCriticality = messageTypeFromMaximizeCalculation(
+									rawValue,
+									kpiDefinition.datapoint.criticalityCalculationThresholds
+								);
+								break;
+						}
+						oKPIModel.setProperty(
+							"/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainCriticality",
+							calculatedCriticality
+						);
+					} else {
+						// No criticality
+						oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainCriticality", MessageType.None);
+					}
+				}
+			}
+		});
+	}
+}
+
+export default KPIManagementControllerExtension;

package/src/sap/fe/core/controllerextensions/PageReady.js

@@ -72,8 +72,7 @@ sap.ui.define(["sap/ui/core/mvc/ControllerExtension", "sap/ui/core/mvc/OverrideE
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         delete this._oAppComponent;
-
-        this._oContainer.removeEventDelegate(this._fnContainerDelegate);
+        this._oContainer && this._oContainer.removeEventDelegate(this._fnContainerDelegate);
       }
     }, {
       key: "waitFor",
@@ -400,4 +399,4 @@ sap.ui.define(["sap/ui/core/mvc/ControllerExtension", "sap/ui/core/mvc/OverrideE
   }(ControllerExtension), (_applyDecoratedDescriptor(_class2.prototype, "onInit", [_dec2], Object.getOwnPropertyDescriptor(_class2.prototype, "onInit"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onExit", [_dec3], Object.getOwnPropertyDescriptor(_class2.prototype, "onExit"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "waitFor", [Public, Final], Object.getOwnPropertyDescriptor(_class2.prototype, "waitFor"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onRouteMatched", [_dec4], Object.getOwnPropertyDescriptor(_class2.prototype, "onRouteMatched"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onRouteMatchedFinished", [_dec5], Object.getOwnPropertyDescriptor(_class2.prototype, "onRouteMatchedFinished"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onAfterBinding", [_dec6], Object.getOwnPropertyDescriptor(_class2.prototype, "onAfterBinding"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "isPageReady", [Public, Final], Object.getOwnPropertyDescriptor(_class2.prototype, "isPageReady"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "waitPageReady", [Public, Final], Object.getOwnPropertyDescriptor(_class2.prototype, "waitPageReady"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "attachEventOnce", [Public, Final], Object.getOwnPropertyDescriptor(_class2.prototype, "attachEventOnce"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "attachEvent", [Public, Final], Object.getOwnPropertyDescriptor(_class2.prototype, "attachEvent"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "detachEvent", [Public, Final], Object.getOwnPropertyDescriptor(_class2.prototype, "detachEvent"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "isContextExpected", [Private, _dec7], Object.getOwnPropertyDescriptor(_class2.prototype, "isContextExpected"), _class2.prototype)), _class2)) || _class);
   return PageReadyControllerExtension;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["PageReady.ts"],"names":["PageReadyControllerExtension","UI5Class","ControllerExtensionMetadata","Override","Extensible","OverrideExecution","Instead","_nbWaits","_oEventProvider","EventProvider","_oView","base","getView","_oAppComponent","CommonUtils","getAppComponent","_oPageComponent","Component","getOwnerComponentFor","attachContainerDefined","oEvent","registerContainer","getParameter","_oContainer","removeEventDelegate","_fnContainerDelegate","oPromise","finally","setTimeout","catch","_bIsPageReady","checkPageReadyDebounced","oBindingContext","_bAfterBindingAlreadyApplied","aBoundElements","aNotBoundMDCTables","iRequested","iReceived","fnRequested","getSource","detachDataRequested","bDataReceived","fnReceived","sGroupId","fireEvent","detachDataReceived","fnSearch","aMDCTables","filter","oElem","sId","getFilter","forEach","oMDCTable","oRowBinding","getRowBinding","fnAttachDataEvents","attachDataRequested","attachDataReceived","push","Log","error","isContextExpected","undefined","bHasContext","attachEventOnce","oElement","detachEvent","mainObjectBinding","getBinding","aTableInitializedPromises","findAggregatedObjects","oObjectBinding","getObjectBinding","aBindingKeys","Object","keys","mBindingInfos","length","sPropertyName","oListBinding","binding","isA","bTablesLoaded","initialized","then","oError","attachEvent","Promise","all","info","resolve","isPageReady","sEventId","oData","fnFunction","oListener","oContainer","onBeforeShow","bShown","onBeforeHide","onAfterShow","_checkPageReady","addEventDelegate","pageReadyTimer","clearTimeout","bFromNav","fnUIUpdated","sap","ui","getCore","getUIDirty","_bWaitingForRefresh","checkUIUpdated","ControllerExtension","Public","Final","Private"],"mappings":"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","sourceRoot":".","sourcesContent":["import { ControllerExtension, OverrideExecution } from \"sap/ui/core/mvc\";\nimport { ControllerExtensionMetadata } from \"sap/fe/core/controllerextensions\";\nimport { Component } from \"sap/ui/core\";\nimport { AppComponent, CommonUtils } from \"sap/fe/core\";\nimport { ManagedObject, EventProvider } from \"sap/ui/base\";\nimport { Log } from \"sap/base\";\nimport { Context } from \"sap/ui/model\";\nimport { UI5Class, Override, Public, Final, Extensible, Private } from \"../helpers/ClassSupport\";\n\n@UI5Class(\"sap.fe.core.controllerextensions.PageReady\", ControllerExtensionMetadata)\nclass PageReadyControllerExtension extends ControllerExtension {\n\tprivate _oEventProvider!: EventProvider;\n\tprivate _oView: any;\n\tprivate _oAppComponent!: AppComponent;\n\tprivate _oPageComponent!: any;\n\tprivate _oContainer!: any;\n\tprivate _bAfterBindingAlreadyApplied!: boolean;\n\tprivate _fnContainerDelegate: any;\n\tprivate _nbWaits!: number;\n\tprivate _bIsPageReady!: boolean;\n\tprivate _bWaitingForRefresh!: boolean;\n\tprivate bShown!: boolean;\n\tprivate bHasContext!: boolean;\n\tprivate bDataReceived: boolean | undefined;\n\tprivate bTablesLoaded: boolean | undefined;\n\tprivate pageReadyTimer: NodeJS.Timeout | undefined;\n\n\t@Override()\n\tpublic onInit() {\n\t\tthis._nbWaits = 0;\n\t\tthis._oEventProvider = new EventProvider();\n\t\tthis._oView = (this as any).base.getView();\n\t\tthis._oAppComponent = CommonUtils.getAppComponent(this._oView);\n\t\tthis._oPageComponent = Component.getOwnerComponentFor(this._oView);\n\n\t\tif (this._oPageComponent && this._oPageComponent.attachContainerDefined) {\n\t\t\tthis._oPageComponent.attachContainerDefined((oEvent: UI5Event) => this.registerContainer(oEvent.getParameter(\"container\")));\n\t\t} else {\n\t\t\tthis.registerContainer(this._oView);\n\t\t}\n\t}\n\n\t@Override()\n\tpublic onExit() {\n\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t// @ts-ignore\n\t\tdelete this._oAppComponent;\n\t\tthis._oContainer.removeEventDelegate(this._fnContainerDelegate);\n\t}\n\n\t@Public\n\t@Final\n\tpublic waitFor(oPromise: any) {\n\t\tthis._nbWaits++;\n\t\toPromise\n\t\t\t.finally(() => {\n\t\t\t\tsetTimeout(() => {\n\t\t\t\t\tthis._nbWaits--;\n\t\t\t\t}, 0);\n\t\t\t})\n\t\t\t.catch(null);\n\t}\n\t@Override(\"_routing\")\n\tonRouteMatched() {\n\t\tthis._bIsPageReady = false;\n\t}\n\t@Override(\"_routing\")\n\tonRouteMatchedFinished() {\n\t\tthis.checkPageReadyDebounced();\n\t}\n\n\t@Override(\"_routing\")\n\tonAfterBinding(oBindingContext: Context) {\n\t\tif (!this._bAfterBindingAlreadyApplied) {\n\t\t\tthis._bAfterBindingAlreadyApplied = true;\n\t\t\tlet aBoundElements: any[] = [];\n\t\t\tconst aNotBoundMDCTables: any[] = [];\n\t\t\tlet iRequested = 0;\n\t\t\tlet iReceived = 0;\n\t\t\tconst fnRequested = (oEvent: UI5Event) => {\n\t\t\t\toEvent.getSource().detachDataRequested(fnRequested);\n\t\t\t\tiRequested++;\n\t\t\t\tthis.bDataReceived = false;\n\t\t\t};\n\t\t\tconst fnReceived = (oEvent: UI5Event) => {\n\t\t\t\tswitch (oEvent.getSource().sGroupId) {\n\t\t\t\t\tcase \"$auto.Workers\":\n\t\t\t\t\t\tthis._oEventProvider.fireEvent(\"workersBatchReceived\");\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"$auto.Heroes\":\n\t\t\t\t\t\tthis._oEventProvider.fireEvent(\"heroesBatchReceived\");\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tdefault:\n\t\t\t\t}\n\t\t\t\toEvent.getSource().detachDataReceived(fnReceived);\n\t\t\t\tiReceived++;\n\t\t\t\tif (iReceived === iRequested && iRequested !== 0) {\n\t\t\t\t\tiRequested = 0;\n\t\t\t\t\tiReceived = 0;\n\t\t\t\t\tthis.bDataReceived = true;\n\t\t\t\t\tthis.checkPageReadyDebounced();\n\t\t\t\t}\n\t\t\t};\n\t\t\tconst fnSearch = (oEvent: UI5Event) => {\n\t\t\t\tconst aMDCTables = aNotBoundMDCTables.filter(oElem => {\n\t\t\t\t\tif (oEvent.getSource().sId === oElem.getFilter()) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t\treturn false;\n\t\t\t\t});\n\t\t\t\taMDCTables.forEach((oMDCTable: any) => {\n\t\t\t\t\tlet oRowBinding = oMDCTable.getRowBinding();\n\t\t\t\t\tconst fnAttachDataEvents = () => {\n\t\t\t\t\t\toRowBinding.attachDataRequested(fnRequested);\n\t\t\t\t\t\toRowBinding.attachDataReceived(fnReceived);\n\t\t\t\t\t\taBoundElements.push(oRowBinding);\n\t\t\t\t\t};\n\t\t\t\t\tif (oRowBinding) {\n\t\t\t\t\t\tfnAttachDataEvents();\n\t\t\t\t\t} else {\n\t\t\t\t\t\tsetTimeout(() => {\n\t\t\t\t\t\t\toRowBinding = oMDCTable.getRowBinding();\n\t\t\t\t\t\t\tif (oRowBinding) {\n\t\t\t\t\t\t\t\tfnAttachDataEvents();\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tLog.error(\"Cannot attach events to unbound table\");\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}, 0);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t};\n\t\t\tif (this.isContextExpected() && oBindingContext === undefined) {\n\t\t\t\t// Force to mention we are expecting data\n\t\t\t\tthis.bHasContext = false;\n\t\t\t\treturn;\n\t\t\t} else {\n\t\t\t\tthis.bHasContext = true;\n\t\t\t}\n\n\t\t\tthis.attachEventOnce(\n\t\t\t\t\"pageReady\",\n\t\t\t\tnull,\n\t\t\t\t() => {\n\t\t\t\t\taBoundElements.forEach((oElement: any) => {\n\t\t\t\t\t\toElement.detachEvent(\"dataRequested\", fnRequested);\n\t\t\t\t\t\toElement.detachEvent(\"dataReceived\", fnReceived);\n\t\t\t\t\t\toElement.detachEvent(\"search\", fnSearch);\n\t\t\t\t\t});\n\t\t\t\t\tthis._bAfterBindingAlreadyApplied = false;\n\t\t\t\t\taBoundElements = [];\n\t\t\t\t},\n\t\t\t\tnull\n\t\t\t);\n\t\t\tif (oBindingContext) {\n\t\t\t\tconst mainObjectBinding = (oBindingContext as any).getBinding();\n\t\t\t\tmainObjectBinding.attachDataRequested(fnRequested);\n\t\t\t\tmainObjectBinding.attachDataReceived(fnReceived);\n\t\t\t\taBoundElements.push(mainObjectBinding);\n\t\t\t}\n\n\t\t\tconst aTableInitializedPromises: Promise<any>[] = [];\n\t\t\tthis._oView.findAggregatedObjects(true, (oElement: any) => {\n\t\t\t\tconst oObjectBinding = oElement.getObjectBinding();\n\t\t\t\tif (oObjectBinding) {\n\t\t\t\t\t// Register on all object binding (mostly used on object pages)\n\t\t\t\t\toObjectBinding.attachDataRequested(fnRequested);\n\t\t\t\t\toObjectBinding.attachDataReceived(fnReceived);\n\t\t\t\t\taBoundElements.push(oObjectBinding);\n\t\t\t\t} else {\n\t\t\t\t\tconst aBindingKeys = Object.keys(oElement.mBindingInfos);\n\t\t\t\t\tif (aBindingKeys.length > 0) {\n\t\t\t\t\t\taBindingKeys.forEach(sPropertyName => {\n\t\t\t\t\t\t\tconst oListBinding = oElement.mBindingInfos[sPropertyName].binding;\n\t\t\t\t\t\t\t// Register on all list binding, good for basic tables, problematic for MDC, see above\n\t\t\t\t\t\t\tif (oListBinding && oListBinding.isA(\"sap.ui.model.odata.v4.ODataListBinding\")) {\n\t\t\t\t\t\t\t\toListBinding.attachDataRequested(fnRequested);\n\t\t\t\t\t\t\t\toListBinding.attachDataReceived(fnReceived);\n\t\t\t\t\t\t\t\taBoundElements.push(oListBinding);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// This is dirty but MDC Table has a weird loading lifecycle\n\t\t\t\tif (oElement.isA(\"sap.ui.mdc.Table\")) {\n\t\t\t\t\tthis.bTablesLoaded = false;\n\t\t\t\t\t// access binding only after table is bound\n\t\t\t\t\taTableInitializedPromises.push(\n\t\t\t\t\t\toElement\n\t\t\t\t\t\t\t.initialized()\n\t\t\t\t\t\t\t.then(() => {\n\t\t\t\t\t\t\t\tconst oRowBinding = oElement.getRowBinding();\n\t\t\t\t\t\t\t\tif (oRowBinding) {\n\t\t\t\t\t\t\t\t\toRowBinding.attachDataRequested(fnRequested);\n\t\t\t\t\t\t\t\t\toRowBinding.attachDataReceived(fnReceived);\n\t\t\t\t\t\t\t\t\taBoundElements.push(oRowBinding);\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\taNotBoundMDCTables.push(oElement);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.catch(function(oError: Error) {\n\t\t\t\t\t\t\t\tLog.error(\"Cannot find a bound table\", oError as any);\n\t\t\t\t\t\t\t})\n\t\t\t\t\t);\n\t\t\t\t} else if (oElement.isA(\"sap.fe.core.controls.FilterBar\")) {\n\t\t\t\t\toElement.attachEvent(\"search\", fnSearch);\n\t\t\t\t\taBoundElements.push(oElement);\n\t\t\t\t}\n\t\t\t});\n\t\t\tif (aTableInitializedPromises.length > 0) {\n\t\t\t\tPromise.all(aTableInitializedPromises)\n\t\t\t\t\t.then(() => {\n\t\t\t\t\t\tthis.bTablesLoaded = true;\n\t\t\t\t\t\tthis.checkPageReadyDebounced();\n\t\t\t\t\t})\n\t\t\t\t\t.catch(oError => {\n\t\t\t\t\t\tLog.info(\"There was an error with one or multiple table\", oError);\n\t\t\t\t\t\tthis.bTablesLoaded = true;\n\t\t\t\t\t\tthis.checkPageReadyDebounced();\n\t\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n\n\t@Public\n\t@Final\n\tpublic isPageReady() {\n\t\treturn this._bIsPageReady;\n\t}\n\n\t@Public\n\t@Final\n\tpublic waitPageReady(): Promise<void> {\n\t\treturn new Promise(resolve => {\n\t\t\tif (this.isPageReady()) {\n\t\t\t\tresolve();\n\t\t\t} else {\n\t\t\t\tthis.attachEventOnce(\n\t\t\t\t\t\"pageReady\",\n\t\t\t\t\tnull,\n\t\t\t\t\t() => {\n\t\t\t\t\t\tresolve();\n\t\t\t\t\t},\n\t\t\t\t\tthis\n\t\t\t\t);\n\t\t\t}\n\t\t});\n\t}\n\n\t@Public\n\t@Final\n\tpublic attachEventOnce(sEventId: string, oData: any, fnFunction: Function, oListener: any) {\n\t\t// eslint-disable-next-line prefer-rest-params\n\t\treturn this._oEventProvider.attachEventOnce(sEventId, oData, fnFunction, oListener);\n\t}\n\t@Public\n\t@Final\n\tpublic attachEvent(sEventId: string, oData: any, fnFunction: Function, oListener: any) {\n\t\t// eslint-disable-next-line prefer-rest-params\n\t\treturn this._oEventProvider.attachEvent(sEventId, oData, fnFunction, oListener);\n\t}\n\t@Public\n\t@Final\n\tpublic detachEvent(sEventId: string, fnFunction: Function) {\n\t\t// eslint-disable-next-line prefer-rest-params\n\t\treturn this._oEventProvider.detachEvent(sEventId, fnFunction);\n\t}\n\tprivate registerContainer(oContainer: ManagedObject) {\n\t\tthis._oContainer = oContainer;\n\t\tthis._fnContainerDelegate = {\n\t\t\tonBeforeShow: () => {\n\t\t\t\tthis.bShown = false;\n\t\t\t\tthis._bIsPageReady = false;\n\t\t\t},\n\t\t\tonBeforeHide: () => {\n\t\t\t\tthis.bShown = false;\n\t\t\t\tthis._bIsPageReady = false;\n\t\t\t},\n\t\t\tonAfterShow: () => {\n\t\t\t\tthis.bShown = true;\n\t\t\t\tthis._checkPageReady(true);\n\t\t\t}\n\t\t};\n\t\tthis._oContainer.addEventDelegate(this._fnContainerDelegate);\n\t}\n\n\t@Private\n\t@Extensible(OverrideExecution.Instead)\n\tpublic isContextExpected() {\n\t\treturn false;\n\t}\n\n\tpublic checkPageReadyDebounced() {\n\t\tif (this.pageReadyTimer) {\n\t\t\tclearTimeout(this.pageReadyTimer);\n\t\t}\n\t\tthis.pageReadyTimer = setTimeout(() => {\n\t\t\tthis._checkPageReady();\n\t\t}, 200);\n\t}\n\n\tpublic _checkPageReady(bFromNav: boolean = false) {\n\t\tconst fnUIUpdated = () => {\n\t\t\t// Wait until the UI is no longer dirty\n\t\t\tif (!sap.ui.getCore().getUIDirty()) {\n\t\t\t\tsap.ui.getCore().detachEvent(\"UIUpdated\", fnUIUpdated);\n\t\t\t\tthis._bWaitingForRefresh = false;\n\t\t\t\tsetTimeout(() => {\n\t\t\t\t\tthis._checkPageReady();\n\t\t\t\t}, 20);\n\t\t\t}\n\t\t};\n\n\t\t// In case UIUpdate does not get called, check if UI is not dirty and then call _checkPageReady\n\t\tconst checkUIUpdated = () => {\n\t\t\tif (sap.ui.getCore().getUIDirty()) {\n\t\t\t\tsetTimeout(checkUIUpdated, 500);\n\t\t\t} else if (this._bWaitingForRefresh) {\n\t\t\t\tthis._bWaitingForRefresh = false;\n\t\t\t\tsap.ui.getCore().detachEvent(\"UIUpdated\", fnUIUpdated);\n\t\t\t\tthis._checkPageReady();\n\t\t\t}\n\t\t};\n\n\t\tif (\n\t\t\tthis.bShown &&\n\t\t\tthis.bDataReceived !== false &&\n\t\t\tthis.bTablesLoaded !== false &&\n\t\t\t(!this.isContextExpected() || this.bHasContext) // Either no context is expected or there is one\n\t\t) {\n\t\t\tif (this.bDataReceived === true && !bFromNav && !this._bWaitingForRefresh && sap.ui.getCore().getUIDirty()) {\n\t\t\t\t// If we requested data we get notified as soon as the data arrived, so before the next rendering tick\n\t\t\t\tthis.bDataReceived = undefined;\n\t\t\t\tthis._bWaitingForRefresh = true;\n\t\t\t\tsap.ui.getCore().attachEvent(\"UIUpdated\", fnUIUpdated);\n\t\t\t\tsetTimeout(checkUIUpdated, 500);\n\t\t\t} else if ((!this._bWaitingForRefresh && sap.ui.getCore().getUIDirty()) || this._nbWaits !== 0) {\n\t\t\t\tthis._bWaitingForRefresh = true;\n\t\t\t\tsap.ui.getCore().attachEvent(\"UIUpdated\", fnUIUpdated);\n\t\t\t\tsetTimeout(checkUIUpdated, 500);\n\t\t\t} else if (!this._bWaitingForRefresh) {\n\t\t\t\t// In the case we're not waiting for any data (navigating back to a page we already have loaded)\n\t\t\t\t// just wait for a frame to fire the event.\n\t\t\t\tthis._bIsPageReady = true;\n\t\t\t\tthis._oEventProvider.fireEvent(\"pageReady\");\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport default PageReadyControllerExtension;\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["PageReady.ts"],"names":["PageReadyControllerExtension","UI5Class","ControllerExtensionMetadata","Override","Extensible","OverrideExecution","Instead","_nbWaits","_oEventProvider","EventProvider","_oView","base","getView","_oAppComponent","CommonUtils","getAppComponent","_oPageComponent","Component","getOwnerComponentFor","attachContainerDefined","oEvent","registerContainer","getParameter","_oContainer","removeEventDelegate","_fnContainerDelegate","oPromise","finally","setTimeout","catch","_bIsPageReady","checkPageReadyDebounced","oBindingContext","_bAfterBindingAlreadyApplied","aBoundElements","aNotBoundMDCTables","iRequested","iReceived","fnRequested","getSource","detachDataRequested","bDataReceived","fnReceived","sGroupId","fireEvent","detachDataReceived","fnSearch","aMDCTables","filter","oElem","sId","getFilter","forEach","oMDCTable","oRowBinding","getRowBinding","fnAttachDataEvents","attachDataRequested","attachDataReceived","push","Log","error","isContextExpected","undefined","bHasContext","attachEventOnce","oElement","detachEvent","mainObjectBinding","getBinding","aTableInitializedPromises","findAggregatedObjects","oObjectBinding","getObjectBinding","aBindingKeys","Object","keys","mBindingInfos","length","sPropertyName","oListBinding","binding","isA","bTablesLoaded","initialized","then","oError","attachEvent","Promise","all","info","resolve","isPageReady","sEventId","oData","fnFunction","oListener","oContainer","onBeforeShow","bShown","onBeforeHide","onAfterShow","_checkPageReady","addEventDelegate","pageReadyTimer","clearTimeout","bFromNav","fnUIUpdated","sap","ui","getCore","getUIDirty","_bWaitingForRefresh","checkUIUpdated","ControllerExtension","Public","Final","Private"],"mappings":"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","sourceRoot":".","sourcesContent":["import { ControllerExtension, OverrideExecution } from \"sap/ui/core/mvc\";\nimport { ControllerExtensionMetadata } from \"sap/fe/core/controllerextensions\";\nimport { Component } from \"sap/ui/core\";\nimport { AppComponent, CommonUtils } from \"sap/fe/core\";\nimport { ManagedObject, EventProvider } from \"sap/ui/base\";\nimport { Log } from \"sap/base\";\nimport { Context } from \"sap/ui/model\";\nimport { UI5Class, Override, Public, Final, Extensible, Private } from \"../helpers/ClassSupport\";\n\n@UI5Class(\"sap.fe.core.controllerextensions.PageReady\", ControllerExtensionMetadata)\nclass PageReadyControllerExtension extends ControllerExtension {\n\tprivate _oEventProvider!: EventProvider;\n\tprivate _oView: any;\n\tprivate _oAppComponent!: AppComponent;\n\tprivate _oPageComponent!: any;\n\tprivate _oContainer!: any;\n\tprivate _bAfterBindingAlreadyApplied!: boolean;\n\tprivate _fnContainerDelegate: any;\n\tprivate _nbWaits!: number;\n\tprivate _bIsPageReady!: boolean;\n\tprivate _bWaitingForRefresh!: boolean;\n\tprivate bShown!: boolean;\n\tprivate bHasContext!: boolean;\n\tprivate bDataReceived: boolean | undefined;\n\tprivate bTablesLoaded: boolean | undefined;\n\tprivate pageReadyTimer: NodeJS.Timeout | undefined;\n\n\t@Override()\n\tpublic onInit() {\n\t\tthis._nbWaits = 0;\n\t\tthis._oEventProvider = new EventProvider();\n\t\tthis._oView = (this as any).base.getView();\n\t\tthis._oAppComponent = CommonUtils.getAppComponent(this._oView);\n\t\tthis._oPageComponent = Component.getOwnerComponentFor(this._oView);\n\n\t\tif (this._oPageComponent && this._oPageComponent.attachContainerDefined) {\n\t\t\tthis._oPageComponent.attachContainerDefined((oEvent: UI5Event) => this.registerContainer(oEvent.getParameter(\"container\")));\n\t\t} else {\n\t\t\tthis.registerContainer(this._oView);\n\t\t}\n\t}\n\n\t@Override()\n\tpublic onExit() {\n\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t// @ts-ignore\n\t\tdelete this._oAppComponent;\n\t\tthis._oContainer && this._oContainer.removeEventDelegate(this._fnContainerDelegate);\n\t}\n\n\t@Public\n\t@Final\n\tpublic waitFor(oPromise: any) {\n\t\tthis._nbWaits++;\n\t\toPromise\n\t\t\t.finally(() => {\n\t\t\t\tsetTimeout(() => {\n\t\t\t\t\tthis._nbWaits--;\n\t\t\t\t}, 0);\n\t\t\t})\n\t\t\t.catch(null);\n\t}\n\t@Override(\"_routing\")\n\tonRouteMatched() {\n\t\tthis._bIsPageReady = false;\n\t}\n\t@Override(\"_routing\")\n\tonRouteMatchedFinished() {\n\t\tthis.checkPageReadyDebounced();\n\t}\n\n\t@Override(\"_routing\")\n\tonAfterBinding(oBindingContext: Context) {\n\t\tif (!this._bAfterBindingAlreadyApplied) {\n\t\t\tthis._bAfterBindingAlreadyApplied = true;\n\t\t\tlet aBoundElements: any[] = [];\n\t\t\tconst aNotBoundMDCTables: any[] = [];\n\t\t\tlet iRequested = 0;\n\t\t\tlet iReceived = 0;\n\t\t\tconst fnRequested = (oEvent: UI5Event) => {\n\t\t\t\toEvent.getSource().detachDataRequested(fnRequested);\n\t\t\t\tiRequested++;\n\t\t\t\tthis.bDataReceived = false;\n\t\t\t};\n\t\t\tconst fnReceived = (oEvent: UI5Event) => {\n\t\t\t\tswitch (oEvent.getSource().sGroupId) {\n\t\t\t\t\tcase \"$auto.Workers\":\n\t\t\t\t\t\tthis._oEventProvider.fireEvent(\"workersBatchReceived\");\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"$auto.Heroes\":\n\t\t\t\t\t\tthis._oEventProvider.fireEvent(\"heroesBatchReceived\");\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tdefault:\n\t\t\t\t}\n\t\t\t\toEvent.getSource().detachDataReceived(fnReceived);\n\t\t\t\tiReceived++;\n\t\t\t\tif (iReceived === iRequested && iRequested !== 0) {\n\t\t\t\t\tiRequested = 0;\n\t\t\t\t\tiReceived = 0;\n\t\t\t\t\tthis.bDataReceived = true;\n\t\t\t\t\tthis.checkPageReadyDebounced();\n\t\t\t\t}\n\t\t\t};\n\t\t\tconst fnSearch = (oEvent: UI5Event) => {\n\t\t\t\tconst aMDCTables = aNotBoundMDCTables.filter(oElem => {\n\t\t\t\t\tif (oEvent.getSource().sId === oElem.getFilter()) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t\treturn false;\n\t\t\t\t});\n\t\t\t\taMDCTables.forEach((oMDCTable: any) => {\n\t\t\t\t\tlet oRowBinding = oMDCTable.getRowBinding();\n\t\t\t\t\tconst fnAttachDataEvents = () => {\n\t\t\t\t\t\toRowBinding.attachDataRequested(fnRequested);\n\t\t\t\t\t\toRowBinding.attachDataReceived(fnReceived);\n\t\t\t\t\t\taBoundElements.push(oRowBinding);\n\t\t\t\t\t};\n\t\t\t\t\tif (oRowBinding) {\n\t\t\t\t\t\tfnAttachDataEvents();\n\t\t\t\t\t} else {\n\t\t\t\t\t\tsetTimeout(() => {\n\t\t\t\t\t\t\toRowBinding = oMDCTable.getRowBinding();\n\t\t\t\t\t\t\tif (oRowBinding) {\n\t\t\t\t\t\t\t\tfnAttachDataEvents();\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tLog.error(\"Cannot attach events to unbound table\");\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}, 0);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t};\n\t\t\tif (this.isContextExpected() && oBindingContext === undefined) {\n\t\t\t\t// Force to mention we are expecting data\n\t\t\t\tthis.bHasContext = false;\n\t\t\t\treturn;\n\t\t\t} else {\n\t\t\t\tthis.bHasContext = true;\n\t\t\t}\n\n\t\t\tthis.attachEventOnce(\n\t\t\t\t\"pageReady\",\n\t\t\t\tnull,\n\t\t\t\t() => {\n\t\t\t\t\taBoundElements.forEach((oElement: any) => {\n\t\t\t\t\t\toElement.detachEvent(\"dataRequested\", fnRequested);\n\t\t\t\t\t\toElement.detachEvent(\"dataReceived\", fnReceived);\n\t\t\t\t\t\toElement.detachEvent(\"search\", fnSearch);\n\t\t\t\t\t});\n\t\t\t\t\tthis._bAfterBindingAlreadyApplied = false;\n\t\t\t\t\taBoundElements = [];\n\t\t\t\t},\n\t\t\t\tnull\n\t\t\t);\n\t\t\tif (oBindingContext) {\n\t\t\t\tconst mainObjectBinding = (oBindingContext as any).getBinding();\n\t\t\t\tmainObjectBinding.attachDataRequested(fnRequested);\n\t\t\t\tmainObjectBinding.attachDataReceived(fnReceived);\n\t\t\t\taBoundElements.push(mainObjectBinding);\n\t\t\t}\n\n\t\t\tconst aTableInitializedPromises: Promise<any>[] = [];\n\t\t\tthis._oView.findAggregatedObjects(true, (oElement: any) => {\n\t\t\t\tconst oObjectBinding = oElement.getObjectBinding();\n\t\t\t\tif (oObjectBinding) {\n\t\t\t\t\t// Register on all object binding (mostly used on object pages)\n\t\t\t\t\toObjectBinding.attachDataRequested(fnRequested);\n\t\t\t\t\toObjectBinding.attachDataReceived(fnReceived);\n\t\t\t\t\taBoundElements.push(oObjectBinding);\n\t\t\t\t} else {\n\t\t\t\t\tconst aBindingKeys = Object.keys(oElement.mBindingInfos);\n\t\t\t\t\tif (aBindingKeys.length > 0) {\n\t\t\t\t\t\taBindingKeys.forEach(sPropertyName => {\n\t\t\t\t\t\t\tconst oListBinding = oElement.mBindingInfos[sPropertyName].binding;\n\t\t\t\t\t\t\t// Register on all list binding, good for basic tables, problematic for MDC, see above\n\t\t\t\t\t\t\tif (oListBinding && oListBinding.isA(\"sap.ui.model.odata.v4.ODataListBinding\")) {\n\t\t\t\t\t\t\t\toListBinding.attachDataRequested(fnRequested);\n\t\t\t\t\t\t\t\toListBinding.attachDataReceived(fnReceived);\n\t\t\t\t\t\t\t\taBoundElements.push(oListBinding);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// This is dirty but MDC Table has a weird loading lifecycle\n\t\t\t\tif (oElement.isA(\"sap.ui.mdc.Table\")) {\n\t\t\t\t\tthis.bTablesLoaded = false;\n\t\t\t\t\t// access binding only after table is bound\n\t\t\t\t\taTableInitializedPromises.push(\n\t\t\t\t\t\toElement\n\t\t\t\t\t\t\t.initialized()\n\t\t\t\t\t\t\t.then(() => {\n\t\t\t\t\t\t\t\tconst oRowBinding = oElement.getRowBinding();\n\t\t\t\t\t\t\t\tif (oRowBinding) {\n\t\t\t\t\t\t\t\t\toRowBinding.attachDataRequested(fnRequested);\n\t\t\t\t\t\t\t\t\toRowBinding.attachDataReceived(fnReceived);\n\t\t\t\t\t\t\t\t\taBoundElements.push(oRowBinding);\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\taNotBoundMDCTables.push(oElement);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.catch(function(oError: Error) {\n\t\t\t\t\t\t\t\tLog.error(\"Cannot find a bound table\", oError as any);\n\t\t\t\t\t\t\t})\n\t\t\t\t\t);\n\t\t\t\t} else if (oElement.isA(\"sap.fe.core.controls.FilterBar\")) {\n\t\t\t\t\toElement.attachEvent(\"search\", fnSearch);\n\t\t\t\t\taBoundElements.push(oElement);\n\t\t\t\t}\n\t\t\t});\n\t\t\tif (aTableInitializedPromises.length > 0) {\n\t\t\t\tPromise.all(aTableInitializedPromises)\n\t\t\t\t\t.then(() => {\n\t\t\t\t\t\tthis.bTablesLoaded = true;\n\t\t\t\t\t\tthis.checkPageReadyDebounced();\n\t\t\t\t\t})\n\t\t\t\t\t.catch(oError => {\n\t\t\t\t\t\tLog.info(\"There was an error with one or multiple table\", oError);\n\t\t\t\t\t\tthis.bTablesLoaded = true;\n\t\t\t\t\t\tthis.checkPageReadyDebounced();\n\t\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n\n\t@Public\n\t@Final\n\tpublic isPageReady() {\n\t\treturn this._bIsPageReady;\n\t}\n\n\t@Public\n\t@Final\n\tpublic waitPageReady(): Promise<void> {\n\t\treturn new Promise(resolve => {\n\t\t\tif (this.isPageReady()) {\n\t\t\t\tresolve();\n\t\t\t} else {\n\t\t\t\tthis.attachEventOnce(\n\t\t\t\t\t\"pageReady\",\n\t\t\t\t\tnull,\n\t\t\t\t\t() => {\n\t\t\t\t\t\tresolve();\n\t\t\t\t\t},\n\t\t\t\t\tthis\n\t\t\t\t);\n\t\t\t}\n\t\t});\n\t}\n\n\t@Public\n\t@Final\n\tpublic attachEventOnce(sEventId: string, oData: any, fnFunction: Function, oListener: any) {\n\t\t// eslint-disable-next-line prefer-rest-params\n\t\treturn this._oEventProvider.attachEventOnce(sEventId, oData, fnFunction, oListener);\n\t}\n\t@Public\n\t@Final\n\tpublic attachEvent(sEventId: string, oData: any, fnFunction: Function, oListener: any) {\n\t\t// eslint-disable-next-line prefer-rest-params\n\t\treturn this._oEventProvider.attachEvent(sEventId, oData, fnFunction, oListener);\n\t}\n\t@Public\n\t@Final\n\tpublic detachEvent(sEventId: string, fnFunction: Function) {\n\t\t// eslint-disable-next-line prefer-rest-params\n\t\treturn this._oEventProvider.detachEvent(sEventId, fnFunction);\n\t}\n\tprivate registerContainer(oContainer: ManagedObject) {\n\t\tthis._oContainer = oContainer;\n\t\tthis._fnContainerDelegate = {\n\t\t\tonBeforeShow: () => {\n\t\t\t\tthis.bShown = false;\n\t\t\t\tthis._bIsPageReady = false;\n\t\t\t},\n\t\t\tonBeforeHide: () => {\n\t\t\t\tthis.bShown = false;\n\t\t\t\tthis._bIsPageReady = false;\n\t\t\t},\n\t\t\tonAfterShow: () => {\n\t\t\t\tthis.bShown = true;\n\t\t\t\tthis._checkPageReady(true);\n\t\t\t}\n\t\t};\n\t\tthis._oContainer.addEventDelegate(this._fnContainerDelegate);\n\t}\n\n\t@Private\n\t@Extensible(OverrideExecution.Instead)\n\tpublic isContextExpected() {\n\t\treturn false;\n\t}\n\n\tpublic checkPageReadyDebounced() {\n\t\tif (this.pageReadyTimer) {\n\t\t\tclearTimeout(this.pageReadyTimer);\n\t\t}\n\t\tthis.pageReadyTimer = setTimeout(() => {\n\t\t\tthis._checkPageReady();\n\t\t}, 200);\n\t}\n\n\tpublic _checkPageReady(bFromNav: boolean = false) {\n\t\tconst fnUIUpdated = () => {\n\t\t\t// Wait until the UI is no longer dirty\n\t\t\tif (!sap.ui.getCore().getUIDirty()) {\n\t\t\t\tsap.ui.getCore().detachEvent(\"UIUpdated\", fnUIUpdated);\n\t\t\t\tthis._bWaitingForRefresh = false;\n\t\t\t\tsetTimeout(() => {\n\t\t\t\t\tthis._checkPageReady();\n\t\t\t\t}, 20);\n\t\t\t}\n\t\t};\n\n\t\t// In case UIUpdate does not get called, check if UI is not dirty and then call _checkPageReady\n\t\tconst checkUIUpdated = () => {\n\t\t\tif (sap.ui.getCore().getUIDirty()) {\n\t\t\t\tsetTimeout(checkUIUpdated, 500);\n\t\t\t} else if (this._bWaitingForRefresh) {\n\t\t\t\tthis._bWaitingForRefresh = false;\n\t\t\t\tsap.ui.getCore().detachEvent(\"UIUpdated\", fnUIUpdated);\n\t\t\t\tthis._checkPageReady();\n\t\t\t}\n\t\t};\n\n\t\tif (\n\t\t\tthis.bShown &&\n\t\t\tthis.bDataReceived !== false &&\n\t\t\tthis.bTablesLoaded !== false &&\n\t\t\t(!this.isContextExpected() || this.bHasContext) // Either no context is expected or there is one\n\t\t) {\n\t\t\tif (this.bDataReceived === true && !bFromNav && !this._bWaitingForRefresh && sap.ui.getCore().getUIDirty()) {\n\t\t\t\t// If we requested data we get notified as soon as the data arrived, so before the next rendering tick\n\t\t\t\tthis.bDataReceived = undefined;\n\t\t\t\tthis._bWaitingForRefresh = true;\n\t\t\t\tsap.ui.getCore().attachEvent(\"UIUpdated\", fnUIUpdated);\n\t\t\t\tsetTimeout(checkUIUpdated, 500);\n\t\t\t} else if ((!this._bWaitingForRefresh && sap.ui.getCore().getUIDirty()) || this._nbWaits !== 0) {\n\t\t\t\tthis._bWaitingForRefresh = true;\n\t\t\t\tsap.ui.getCore().attachEvent(\"UIUpdated\", fnUIUpdated);\n\t\t\t\tsetTimeout(checkUIUpdated, 500);\n\t\t\t} else if (!this._bWaitingForRefresh) {\n\t\t\t\t// In the case we're not waiting for any data (navigating back to a page we already have loaded)\n\t\t\t\t// just wait for a frame to fire the event.\n\t\t\t\tthis._bIsPageReady = true;\n\t\t\t\tthis._oEventProvider.fireEvent(\"pageReady\");\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport default PageReadyControllerExtension;\n"]}

package/src/sap/fe/core/controllerextensions/PageReady.ts

@@ -45,7 +45,7 @@ class PageReadyControllerExtension extends ControllerExtension {
 		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
 		// @ts-ignore
 		delete this._oAppComponent;
-		this._oContainer.removeEventDelegate(this._fnContainerDelegate);
+		this._oContainer && this._oContainer.removeEventDelegate(this._fnContainerDelegate);
 	}
 
 	@Public