@sapui5/sap.fe.core 1.102.4 → 1.102.6

package/src/sap/fe/core/controllerextensions/pageReady/DataQueryWatcher.js

@@ -0,0 +1,397 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/Log"], function (Log) {
+  "use strict";
+
+  function _catch(body, recover) {
+    try {
+      var result = body();
+    } catch (e) {
+      return recover(e);
+    }
+
+    if (result && result.then) {
+      return result.then(void 0, recover);
+    }
+
+    return result;
+  }
+
+  var DataQueryWatcher = /*#__PURE__*/function () {
+    function DataQueryWatcher(_oEventProvider, _fnOnFinished) {
+      this._aBindingRegistrations = [];
+      this._aOtherEventSources = [];
+      this._isSearchPending = false;
+      this._aMDCTables = [];
+      this._aMDCCharts = [];
+      this._oEventProvider = _oEventProvider;
+      this._fnOnFinished = _fnOnFinished;
+    } // Accessors
+
+
+    var _proto = DataQueryWatcher.prototype;
+
+    _proto.isSearchPending = function isSearchPending() {
+      return this._isSearchPending;
+    };
+
+    _proto.isDataReceived = function isDataReceived() {
+      return this._isDataReceived;
+    };
+
+    _proto.resetDataReceived = function resetDataReceived() {
+      this._isDataReceived = undefined;
+    }
+    /**
+     * Reset the state: unsubscribe to all data events and remove all registered objects.
+     */
+    ;
+
+    _proto.reset = function reset() {
+      var _this = this;
+
+      // Remove all remaining callbacks
+      this._aBindingRegistrations.forEach(function (reg) {
+        reg.binding.detachEvent("dataRequested", _this.onDataRequested, _this);
+        reg.binding.detachEvent("dataReceived", _this.onDataReceived, _this);
+      });
+
+      this._aOtherEventSources.forEach(function (oElement) {
+        oElement.detachEvent("search", _this.onSearch, _this);
+        oElement.detachEvent("bindingUpdated", _this.register, _this);
+      });
+
+      this._aBindingRegistrations = [];
+      this._aOtherEventSources = [];
+      this._aMDCTables = [];
+      this._aMDCCharts = [];
+      this._isSearchPending = false;
+      this._isDataReceived = undefined;
+    } // //////////////////////////////////////////////////
+    // Callback when data is received on a binding.
+    ;
+
+    _proto.onDataReceived = function onDataReceived(oEvent, params) {
+      // Look for the corresponding binding registration
+      var binding = oEvent.getSource();
+
+      var bindingRegistration = this._aBindingRegistrations.find(function (reg) {
+        return reg.binding === binding;
+      });
+
+      if (!bindingRegistration) {
+        Log.error("PageReady - data received on an unregistered binding");
+        return;
+      }
+
+      switch (binding.getGroupId()) {
+        case "$auto.Workers":
+          this._oEventProvider.fireEvent("workersBatchReceived");
+
+          break;
+
+        case "$auto.Heroes":
+          this._oEventProvider.fireEvent("heroesBatchReceived");
+
+          break;
+
+        default:
+      }
+
+      bindingRegistration.receivedCount++;
+
+      if (bindingRegistration.receivedCount < bindingRegistration.requestedCount) {
+        // There are other request pending --> resubscribe to wait until they return
+        binding.attachEventOnce("dataReceived", {
+          triggeredBySearch: params.triggeredBySearch
+        }, this.onDataReceived, this);
+        return;
+      } // Check if at least one binding has requested data, and all bindings that have requested data have received it
+
+
+      var bAllDone = this._aBindingRegistrations.some(function (reg) {
+        return reg.requestedCount !== 0;
+      }) && this._aBindingRegistrations.every(function (reg) {
+        return reg.requestedCount === 0 || reg.receivedCount >= reg.requestedCount;
+      });
+
+      if (params.triggeredBySearch || bindingRegistration.receivedCount >= bindingRegistration.requestedCount) {
+        this._isSearchPending = false;
+      }
+
+      if (bAllDone) {
+        this._isDataReceived = true;
+
+        this._fnOnFinished();
+      }
+    } // //////////////////////////////////////////////////
+    // Callback when data is requested on a binding.
+    ;
+
+    _proto.onDataRequested = function onDataRequested(oEvent, params) {
+      // Look for the corresponding binding registration
+      var binding = oEvent.getSource();
+
+      var bindingRegistration = this._aBindingRegistrations.find(function (reg) {
+        return reg.binding === binding;
+      });
+
+      if (!bindingRegistration) {
+        Log.error("PageReady - data requested on an unregistered binding");
+        return;
+      }
+
+      bindingRegistration.requestedCount++;
+      this._isDataReceived = false;
+
+      if (bindingRegistration.requestedCount - bindingRegistration.receivedCount === 1) {
+        // Listen to dataReceived only if there's no other request pending
+        // Otherwise the 'dataReceived' handler would be called several times when the first query returns
+        // and we wouldn't wait for all queries to be finished
+        // (we will resubscribe to the dataReceived event in onDataReceived if necessary)
+        binding.attachEventOnce("dataReceived", {
+          triggeredBySearch: params.triggeredBySearch
+        }, this.onDataReceived, this);
+      }
+    } // //////////////////////////////////////////////////
+    // Callback when a search is triggered from a filterbar
+    ;
+
+    _proto.onSearch = function onSearch(oEvent) {
+      var _this3 = this;
+
+      var _this2 = this;
+
+      var aMDCTableLinkedToFilterBar = this._aMDCTables.filter(function (oTable) {
+        return oEvent.getSource().sId === oTable.getFilter() && oTable.getVisible();
+      });
+
+      var aMDCChartsLinkedToFilterBar = this._aMDCCharts.filter(function (oChart) {
+        return oEvent.getSource().sId === oChart.getFilter() && oChart.getVisible();
+      });
+
+      if (aMDCTableLinkedToFilterBar.length > 0 || aMDCChartsLinkedToFilterBar.length > 0) {
+        this._isSearchPending = true;
+      }
+
+      aMDCTableLinkedToFilterBar.forEach(function (oTable) {
+        _this2.registerTable(oTable, true);
+      });
+      aMDCChartsLinkedToFilterBar.forEach(function (oChart) {
+        try {
+          var _temp4 = _catch(function () {
+            function _temp2() {
+              _this3.registerChart(oChart, true);
+            }
+
+            var _temp = function () {
+              if (oChart.innerChartBoundPromise) {
+                return Promise.resolve(oChart.innerChartBoundPromise).then(function () {});
+              }
+            }();
+
+            return _temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp);
+          }, function (oError) {
+            Log.error("Cannot find a inner bound chart", oError);
+          });
+
+          return Promise.resolve(_temp4 && _temp4.then ? _temp4.then(function () {}) : void 0);
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+    } // //////////////////////////////////////////////////
+    // Register a binding (with an optional table/chart)
+    // and attach callbacks on dateRequested/dataReceived events
+    ;
+
+    _proto.register = function register(_event, data) {
+      var _data$table, _data$chart;
+
+      var binding = data.binding || ((_data$table = data.table) === null || _data$table === void 0 ? void 0 : _data$table.getRowBinding()) || ((_data$chart = data.chart) === null || _data$chart === void 0 ? void 0 : _data$chart.getControlDelegate().getInnerChart(data.chart).getBinding("data"));
+      var boundControl = data.table || data.chart;
+
+      if (!binding) {
+        return;
+      } // Check if the binding is already registered
+
+
+      var bindingRegistration = this._aBindingRegistrations.find(function (reg) {
+        return reg.binding === binding;
+      });
+
+      if (bindingRegistration) {
+        if (boundControl) {
+          // The binding was already registerd without boundControl information --> update boundControl
+          bindingRegistration.boundControl = boundControl;
+        } // This binding has already requested data, but we're registering it again (on search) --> attach to dataRequested again
+
+
+        if (bindingRegistration.requestedCount > 0) {
+          binding.attachEventOnce("dataRequested", {
+            triggeredBySearch: data.triggeredBySearch
+          }, this.onDataRequested, this);
+        }
+
+        return;
+      }
+
+      if (boundControl) {
+        // Check if there's a different binding registered for the bound control
+        bindingRegistration = this._aBindingRegistrations.find(function (reg) {
+          return reg.boundControl === boundControl;
+        });
+
+        if (bindingRegistration && bindingRegistration.binding !== binding) {
+          // The control had a different binding. This can happen in case of MDC charts who recreated their binding after search
+          // The previous binding is destroyed, we can replace it with the new and reset counters
+          bindingRegistration.binding = binding;
+          bindingRegistration.requestedCount = 0;
+          bindingRegistration.receivedCount = 0;
+        }
+      }
+
+      if (!bindingRegistration) {
+        bindingRegistration = {
+          binding: binding,
+          boundControl: boundControl,
+          requestedCount: 0,
+          receivedCount: 0
+        };
+
+        this._aBindingRegistrations.push(bindingRegistration);
+      }
+
+      binding.attachEventOnce("dataRequested", {
+        triggeredBySearch: data.triggeredBySearch
+      }, this.onDataRequested, this);
+    }
+    /**
+     * Registers a binding for watching its data events (dataRequested and dataReceived).
+     *
+     * @param binding The binding
+     */
+    ;
+
+    _proto.registerBinding = function registerBinding(binding) {
+      this.register(null, {
+        binding: binding,
+        triggeredBySearch: false
+      });
+    }
+    /**
+     * Registers an MDCTable for watching the data events on its row binding (dataRequested and dataReceived).
+     *
+     * @param table The table
+     * @param triggeredBySearch True if this registration is triggered by a filterBar search
+     */
+    ;
+
+    _proto.registerTable = function registerTable(table) {
+      var triggeredBySearch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+      if (this._aMDCTables.indexOf(table) < 0) {
+        this._aMDCTables.push(table);
+      }
+
+      var oRowBinding = table.getRowBinding();
+
+      if (oRowBinding) {
+        this.register(null, {
+          table: table,
+          triggeredBySearch: triggeredBySearch
+        });
+      } else {
+        table.attachEventOnce("bindingUpdated", {
+          table: table,
+          triggeredBySearch: triggeredBySearch
+        }, this.register, this);
+
+        this._aOtherEventSources.push(table);
+      }
+    }
+    /**
+     * Registers an MDCChart for watching the data events on its inner data binding (dataRequested and dataReceived).
+     *
+     * @param chart The chart
+     * @param triggeredBySearch True if this registration is triggered by a filter bar search
+     */
+    ;
+
+    _proto.registerChart = function registerChart(chart) {
+      var triggeredBySearch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+      if (this._aMDCCharts.indexOf(chart) < 0) {
+        this._aMDCCharts.push(chart);
+      }
+
+      var oInnerChart = chart.getControlDelegate().getInnerChart(chart);
+      var binding = oInnerChart === null || oInnerChart === void 0 ? void 0 : oInnerChart.getBinding("data");
+
+      if (binding) {
+        this.register(null, {
+          chart: chart,
+          triggeredBySearch: triggeredBySearch
+        });
+      } else {
+        chart.attachEventOnce("bindingUpdated", {
+          chart: chart,
+          triggeredBySearch: triggeredBySearch
+        }, this.register, this);
+
+        this._aOtherEventSources.push(chart);
+      }
+    }
+    /**
+     * Registers an MDCTable or MDCChart for watching the data events on its inner data binding (dataRequested and dataReceived).
+     *
+     * @param element  The table or cchart
+     */
+    ;
+
+    _proto.registerTableOrChart = function registerTableOrChart(element) {
+      try {
+        var _this5 = this;
+
+        if (!element.isA("sap.ui.mdc.Table") && !element.isA("sap.ui.mdc.Chart")) {
+          return Promise.resolve();
+        }
+
+        var _temp6 = _catch(function () {
+          return Promise.resolve(element.initialized()).then(function () {
+            if (element.isA("sap.ui.mdc.Table")) {
+              _this5.registerTable(element);
+            } else {
+              _this5.registerChart(element);
+            }
+          }); // access binding only after table/chart is bound
+        }, function (oError) {
+          Log.error("PageReady - Cannot register a table or a chart", oError);
+        });
+
+        return Promise.resolve(_temp6 && _temp6.then ? _temp6.then(function () {}) : void 0);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Registers an MDCFilterBar for watching its search event.
+     *
+     * @param filterBar The filter bar
+     */
+    ;
+
+    _proto.registerFilterBar = function registerFilterBar(filterBar) {
+      filterBar.attachEvent("search", this.onSearch, this);
+
+      this._aOtherEventSources.push(filterBar);
+    };
+
+    return DataQueryWatcher;
+  }();
+
+  return DataQueryWatcher;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["DataQueryWatcher.ts"],"names":["body","recover","result","e","then","DataQueryWatcher","_oEventProvider","_fnOnFinished","_aBindingRegistrations","_aOtherEventSources","_isSearchPending","_aMDCTables","_aMDCCharts","isSearchPending","isDataReceived","_isDataReceived","resetDataReceived","undefined","reset","forEach","reg","binding","detachEvent","onDataRequested","onDataReceived","oElement","onSearch","register","oEvent","params","getSource","bindingRegistration","find","Log","error","getGroupId","fireEvent","receivedCount","requestedCount","attachEventOnce","triggeredBySearch","bAllDone","some","every","aMDCTableLinkedToFilterBar","filter","oTable","sId","getFilter","getVisible","aMDCChartsLinkedToFilterBar","oChart","length","registerTable","registerChart","innerChartBoundPromise","oError","_event","data","table","getRowBinding","chart","getControlDelegate","getInnerChart","getBinding","boundControl","push","registerBinding","indexOf","oRowBinding","oInnerChart","registerTableOrChart","element","isA","initialized","registerFilterBar","filterBar","attachEvent"],"mappings":"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","sourceRoot":".","sourcesContent":["import Log from \"sap/base/Log\";\nimport type Event from \"sap/ui/base/Event\";\nimport EventProvider from \"sap/ui/base/EventProvider\";\nimport Control from \"sap/ui/core/Control\";\nimport Chart from \"sap/ui/mdc/Chart\";\nimport FilterBar from \"sap/ui/mdc/FilterBar\";\nimport Table from \"sap/ui/mdc/Table\";\nimport Binding from \"sap/ui/model/Binding\";\n\nclass DataQueryWatcher {\n\tprotected _aBindingRegistrations: { binding: Binding; boundControl?: Control; requestedCount: number; receivedCount: number }[] = [];\n\tprotected _aOtherEventSources: EventProvider[] = [];\n\tprotected _isSearchPending = false;\n\tprotected _isDataReceived?: boolean;\n\tprotected _aMDCTables: Table[] = [];\n\tprotected _aMDCCharts: Chart[] = [];\n\n\tpublic constructor(protected _oEventProvider: EventProvider, protected _fnOnFinished: () => void) {}\n\n\t// Accessors\n\tpublic isSearchPending() {\n\t\treturn this._isSearchPending;\n\t}\n\tpublic isDataReceived() {\n\t\treturn this._isDataReceived;\n\t}\n\tpublic resetDataReceived() {\n\t\tthis._isDataReceived = undefined;\n\t}\n\n\t/**\n\t * Reset the state: unsubscribe to all data events and remove all registered objects.\n\t */\n\tpublic reset(): void {\n\t\t// Remove all remaining callbacks\n\t\tthis._aBindingRegistrations.forEach((reg) => {\n\t\t\treg.binding.detachEvent(\"dataRequested\", this.onDataRequested, this);\n\t\t\treg.binding.detachEvent(\"dataReceived\", this.onDataReceived, this);\n\t\t});\n\t\tthis._aOtherEventSources.forEach((oElement: any) => {\n\t\t\toElement.detachEvent(\"search\", this.onSearch, this);\n\t\t\toElement.detachEvent(\"bindingUpdated\", this.register, this);\n\t\t});\n\n\t\tthis._aBindingRegistrations = [];\n\t\tthis._aOtherEventSources = [];\n\t\tthis._aMDCTables = [];\n\t\tthis._aMDCCharts = [];\n\t\tthis._isSearchPending = false;\n\t\tthis._isDataReceived = undefined;\n\t}\n\n\t// //////////////////////////////////////////////////\n\t// Callback when data is received on a binding.\n\tprotected onDataReceived(oEvent: Event, params: { triggeredBySearch: boolean }): void {\n\t\t// Look for the corresponding binding registration\n\t\tconst binding = oEvent.getSource() as Binding;\n\t\tconst bindingRegistration = this._aBindingRegistrations.find((reg) => {\n\t\t\treturn reg.binding === binding;\n\t\t});\n\t\tif (!bindingRegistration) {\n\t\t\tLog.error(\"PageReady - data received on an unregistered binding\");\n\t\t\treturn;\n\t\t}\n\n\t\tswitch ((binding as any).getGroupId()) {\n\t\t\tcase \"$auto.Workers\":\n\t\t\t\tthis._oEventProvider.fireEvent(\"workersBatchReceived\");\n\t\t\t\tbreak;\n\t\t\tcase \"$auto.Heroes\":\n\t\t\t\tthis._oEventProvider.fireEvent(\"heroesBatchReceived\");\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t}\n\t\tbindingRegistration.receivedCount++;\n\n\t\tif (bindingRegistration.receivedCount < bindingRegistration.requestedCount) {\n\t\t\t// There are other request pending --> resubscribe to wait until they return\n\t\t\tbinding.attachEventOnce(\"dataReceived\", { triggeredBySearch: params.triggeredBySearch }, this.onDataReceived, this);\n\t\t\treturn;\n\t\t}\n\n\t\t// Check if at least one binding has requested data, and all bindings that have requested data have received it\n\t\tconst bAllDone =\n\t\t\tthis._aBindingRegistrations.some((reg) => {\n\t\t\t\treturn reg.requestedCount !== 0;\n\t\t\t}) &&\n\t\t\tthis._aBindingRegistrations.every((reg) => {\n\t\t\t\treturn reg.requestedCount === 0 || reg.receivedCount >= reg.requestedCount;\n\t\t\t});\n\n\t\tif (params.triggeredBySearch || bindingRegistration.receivedCount >= bindingRegistration.requestedCount) {\n\t\t\tthis._isSearchPending = false;\n\t\t}\n\n\t\tif (bAllDone) {\n\t\t\tthis._isDataReceived = true;\n\t\t\tthis._fnOnFinished();\n\t\t}\n\t}\n\n\t// //////////////////////////////////////////////////\n\t// Callback when data is requested on a binding.\n\tprotected onDataRequested(oEvent: Event, params: { triggeredBySearch: boolean }): void {\n\t\t// Look for the corresponding binding registration\n\t\tconst binding = oEvent.getSource() as Binding;\n\t\tconst bindingRegistration = this._aBindingRegistrations.find((reg) => {\n\t\t\treturn reg.binding === binding;\n\t\t});\n\t\tif (!bindingRegistration) {\n\t\t\tLog.error(\"PageReady - data requested on an unregistered binding\");\n\t\t\treturn;\n\t\t}\n\n\t\tbindingRegistration.requestedCount++;\n\t\tthis._isDataReceived = false;\n\n\t\tif (bindingRegistration.requestedCount - bindingRegistration.receivedCount === 1) {\n\t\t\t// Listen to dataReceived only if there's no other request pending\n\t\t\t// Otherwise the 'dataReceived' handler would be called several times when the first query returns\n\t\t\t// and we wouldn't wait for all queries to be finished\n\t\t\t// (we will resubscribe to the dataReceived event in onDataReceived if necessary)\n\t\t\tbinding.attachEventOnce(\"dataReceived\", { triggeredBySearch: params.triggeredBySearch }, this.onDataReceived, this);\n\t\t}\n\t}\n\n\t// //////////////////////////////////////////////////\n\t// Callback when a search is triggered from a filterbar\n\tprotected onSearch(oEvent: Event): void {\n\t\tconst aMDCTableLinkedToFilterBar = this._aMDCTables.filter((oTable) => {\n\t\t\treturn (oEvent.getSource() as any).sId === oTable.getFilter() && oTable.getVisible();\n\t\t});\n\t\tconst aMDCChartsLinkedToFilterBar = this._aMDCCharts.filter((oChart) => {\n\t\t\treturn (oEvent.getSource() as any).sId === oChart.getFilter() && oChart.getVisible();\n\t\t});\n\n\t\tif (aMDCTableLinkedToFilterBar.length > 0 || aMDCChartsLinkedToFilterBar.length > 0) {\n\t\t\tthis._isSearchPending = true;\n\t\t}\n\t\taMDCTableLinkedToFilterBar.forEach((oTable) => {\n\t\t\tthis.registerTable(oTable, true);\n\t\t});\n\t\taMDCChartsLinkedToFilterBar.forEach(async (oChart: any) => {\n\t\t\ttry {\n\t\t\t\tif (oChart.innerChartBoundPromise) {\n\t\t\t\t\tawait oChart.innerChartBoundPromise;\n\t\t\t\t}\n\t\t\t\tthis.registerChart(oChart, true);\n\t\t\t} catch (oError: any) {\n\t\t\t\tLog.error(\"Cannot find a inner bound chart\", oError);\n\t\t\t}\n\t\t});\n\t}\n\n\t// //////////////////////////////////////////////////\n\t// Register a binding (with an optional table/chart)\n\t// and attach callbacks on dateRequested/dataReceived events\n\tprotected register(_event: Event | null, data: { binding?: Binding; table?: Table; chart?: Chart; triggeredBySearch: boolean }): void {\n\t\tconst binding: Binding | undefined =\n\t\t\tdata.binding ||\n\t\t\tdata.table?.getRowBinding() ||\n\t\t\t(data.chart as any)?.getControlDelegate().getInnerChart(data.chart).getBinding(\"data\");\n\t\tconst boundControl = (data.table || data.chart) as Control | undefined;\n\n\t\tif (!binding) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Check if the binding is already registered\n\t\tlet bindingRegistration = this._aBindingRegistrations.find((reg) => {\n\t\t\treturn reg.binding === binding;\n\t\t});\n\t\tif (bindingRegistration) {\n\t\t\tif (boundControl) {\n\t\t\t\t// The binding was already registerd without boundControl information --> update boundControl\n\t\t\t\tbindingRegistration.boundControl = boundControl;\n\t\t\t}\n\n\t\t\t// This binding has already requested data, but we're registering it again (on search) --> attach to dataRequested again\n\t\t\tif (bindingRegistration.requestedCount > 0) {\n\t\t\t\tbinding.attachEventOnce(\"dataRequested\", { triggeredBySearch: data.triggeredBySearch }, this.onDataRequested, this);\n\t\t\t}\n\n\t\t\treturn;\n\t\t}\n\n\t\tif (boundControl) {\n\t\t\t// Check if there's a different binding registered for the bound control\n\t\t\tbindingRegistration = this._aBindingRegistrations.find((reg) => {\n\t\t\t\treturn reg.boundControl === boundControl;\n\t\t\t});\n\t\t\tif (bindingRegistration && bindingRegistration.binding !== binding) {\n\t\t\t\t// The control had a different binding. This can happen in case of MDC charts who recreated their binding after search\n\t\t\t\t// The previous binding is destroyed, we can replace it with the new and reset counters\n\t\t\t\tbindingRegistration.binding = binding;\n\t\t\t\tbindingRegistration.requestedCount = 0;\n\t\t\t\tbindingRegistration.receivedCount = 0;\n\t\t\t}\n\t\t}\n\t\tif (!bindingRegistration) {\n\t\t\tbindingRegistration = {\n\t\t\t\tbinding: binding,\n\t\t\t\tboundControl: boundControl,\n\t\t\t\trequestedCount: 0,\n\t\t\t\treceivedCount: 0\n\t\t\t};\n\t\t\tthis._aBindingRegistrations.push(bindingRegistration);\n\t\t}\n\n\t\tbinding.attachEventOnce(\"dataRequested\", { triggeredBySearch: data.triggeredBySearch }, this.onDataRequested, this);\n\t}\n\n\t/**\n\t * Registers a binding for watching its data events (dataRequested and dataReceived).\n\t *\n\t * @param binding The binding\n\t */\n\tpublic registerBinding(binding: Binding) {\n\t\tthis.register(null, { binding, triggeredBySearch: false });\n\t}\n\n\t/**\n\t * Registers an MDCTable for watching the data events on its row binding (dataRequested and dataReceived).\n\t *\n\t * @param table The table\n\t * @param triggeredBySearch True if this registration is triggered by a filterBar search\n\t */\n\tprotected registerTable(table: Table, triggeredBySearch = false) {\n\t\tif (this._aMDCTables.indexOf(table) < 0) {\n\t\t\tthis._aMDCTables.push(table);\n\t\t}\n\t\tconst oRowBinding = table.getRowBinding();\n\t\tif (oRowBinding) {\n\t\t\tthis.register(null, { table, triggeredBySearch });\n\t\t} else {\n\t\t\ttable.attachEventOnce(\"bindingUpdated\", { table, triggeredBySearch }, this.register, this);\n\t\t\tthis._aOtherEventSources.push(table);\n\t\t}\n\t}\n\n\t/**\n\t * Registers an MDCChart for watching the data events on its inner data binding (dataRequested and dataReceived).\n\t *\n\t * @param chart The chart\n\t * @param triggeredBySearch True if this registration is triggered by a filter bar search\n\t */\n\tprotected registerChart(chart: Chart, triggeredBySearch = false) {\n\t\tif (this._aMDCCharts.indexOf(chart) < 0) {\n\t\t\tthis._aMDCCharts.push(chart);\n\t\t}\n\n\t\tconst oInnerChart = (chart as any).getControlDelegate().getInnerChart(chart);\n\t\tconst binding = oInnerChart?.getBinding(\"data\");\n\t\tif (binding) {\n\t\t\tthis.register(null, { chart, triggeredBySearch });\n\t\t} else {\n\t\t\tchart.attachEventOnce(\"bindingUpdated\", { chart, triggeredBySearch }, this.register, this);\n\t\t\tthis._aOtherEventSources.push(chart);\n\t\t}\n\t}\n\n\t/**\n\t * Registers an MDCTable or MDCChart for watching the data events on its inner data binding (dataRequested and dataReceived).\n\t *\n\t * @param element  The table or cchart\n\t */\n\tpublic async registerTableOrChart(element: Table | Chart): Promise<void> {\n\t\tif (!element.isA(\"sap.ui.mdc.Table\") && !element.isA(\"sap.ui.mdc.Chart\")) {\n\t\t\treturn;\n\t\t}\n\n\t\ttry {\n\t\t\tawait element.initialized(); // access binding only after table/chart is bound\n\t\t\tif (element.isA(\"sap.ui.mdc.Table\")) {\n\t\t\t\tthis.registerTable(element as Table);\n\t\t\t} else {\n\t\t\t\tthis.registerChart(element as Chart);\n\t\t\t}\n\t\t} catch (oError: any) {\n\t\t\tLog.error(\"PageReady - Cannot register a table or a chart\", oError);\n\t\t}\n\t}\n\n\t/**\n\t * Registers an MDCFilterBar for watching its search event.\n\t *\n\t * @param filterBar The filter bar\n\t */\n\tpublic registerFilterBar(filterBar: FilterBar) {\n\t\tfilterBar.attachEvent(\"search\", this.onSearch, this);\n\t\tthis._aOtherEventSources.push(filterBar);\n\t}\n}\n\nexport default DataQueryWatcher;\n"]}