@sapui5/sap.fe.core 1.110.0 → 1.111.0

package/src/sap/fe/core/controllerextensions/InternalIntentBasedNavigation-dbg.js

@@ -0,0 +1,791 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2023 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/Log", "sap/base/util/merge", "sap/fe/core/CommonUtils", "sap/fe/core/controllerextensions/editFlow/draft", "sap/fe/core/converters/MetaModelConverter", "sap/fe/core/helpers/ClassSupport", "sap/fe/core/helpers/KeepAliveHelper", "sap/fe/core/helpers/ModelHelper", "sap/fe/navigation/SelectionVariant", "sap/ui/core/Core", "sap/ui/core/Fragment", "sap/ui/core/mvc/ControllerExtension", "sap/ui/core/mvc/OverrideExecution", "sap/ui/core/util/XMLPreprocessor", "sap/ui/core/XMLTemplateProcessor", "sap/ui/model/json/JSONModel", "../converters/helpers/Aggregation"], function (Log, mergeObjects, CommonUtils, draft, MetaModelConverter, ClassSupport, KeepAliveHelper, ModelHelper, SelectionVariant, Core, Fragment, ControllerExtension, OverrideExecution, XMLPreprocessor, XMLTemplateProcessor, JSONModel, Aggregation) {
+  "use strict";
+
+  var _dec, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec10, _dec11, _dec12, _dec13, _dec14, _dec15, _dec16, _dec17, _dec18, _dec19, _dec20, _dec21, _class, _class2;
+  var AggregationHelper = Aggregation.AggregationHelper;
+  var publicExtension = ClassSupport.publicExtension;
+  var privateExtension = ClassSupport.privateExtension;
+  var methodOverride = ClassSupport.methodOverride;
+  var finalExtension = ClassSupport.finalExtension;
+  var extensible = ClassSupport.extensible;
+  var defineUI5Class = ClassSupport.defineUI5Class;
+  function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+  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; }
+  /**
+   * {@link sap.ui.core.mvc.ControllerExtension Controller extension}
+   *
+   * @namespace
+   * @alias sap.fe.core.controllerextensions.InternalInternalBasedNavigation
+   * @private
+   * @since 1.84.0
+   */
+  let InternalIntentBasedNavigation = (_dec = defineUI5Class("sap.fe.core.controllerextensions.InternalInternalBasedNavigation"), _dec2 = methodOverride(), _dec3 = publicExtension(), _dec4 = finalExtension(), _dec5 = publicExtension(), _dec6 = finalExtension(), _dec7 = publicExtension(), _dec8 = finalExtension(), _dec9 = publicExtension(), _dec10 = extensible(OverrideExecution.Instead), _dec11 = publicExtension(), _dec12 = finalExtension(), _dec13 = privateExtension(), _dec14 = publicExtension(), _dec15 = finalExtension(), _dec16 = publicExtension(), _dec17 = finalExtension(), _dec18 = publicExtension(), _dec19 = finalExtension(), _dec20 = publicExtension(), _dec21 = finalExtension(), _dec(_class = (_class2 = /*#__PURE__*/function (_ControllerExtension) {
+    _inheritsLoose(InternalIntentBasedNavigation, _ControllerExtension);
+    function InternalIntentBasedNavigation() {
+      return _ControllerExtension.apply(this, arguments) || this;
+    }
+    var _proto = InternalIntentBasedNavigation.prototype;
+    _proto.onInit = function onInit() {
+      this._oAppComponent = this.base.getAppComponent();
+      this._oMetaModel = this._oAppComponent.getModel().getMetaModel();
+      this._oNavigationService = this._oAppComponent.getNavigationService();
+      this._oView = this.base.getView();
+    }
+
+    /**
+     * Enables intent-based navigation (SemanticObject-Action) with the provided context.
+     * If semantic object mapping is provided, this is also applied to the selection variant after the adaptation by a consumer.
+     * This takes care of removing any technical parameters and determines if an explace or inplace navigation should take place.
+     *
+     * @param sSemanticObject Semantic object for the target app
+     * @param sAction  Action for the target app
+     * @param [mNavigationParameters] Optional parameters to be passed to the external navigation
+     * @param [mNavigationParameters.navigationContexts] Uses one of the following to be passed to the intent:
+     *    a single instance of {@link sap.ui.model.odata.v4.Context}
+     *    multiple instances of {@link sap.ui.model.odata.v4.Context}
+     *    an object or an array of objects
+     *		  If an array of objects is passed, the context is used to determine the metaPath and to remove any sensitive data
+     *		  If an array of objects is passed, the following format ix expected:
+     *		  {
+     *			data: {
+     *	 			ProductID: 7634,
+     *				Name: "Laptop"
+     *			 },
+     *			 metaPath: "/SalesOrderManage"
+     *        }
+     * @param [mNavigationParameters.semanticObjectMapping] String representation of the SemanticObjectMapping or SemanticObjectMapping that applies to this navigation
+     * @param [mNavigationParameters.defaultRefreshStrategy] Default refresh strategy to be used in case no refresh strategy is specified for the intent in the view.
+     * @param [mNavigationParameters.refreshStrategies]
+     * @param [mNavigationParameters.additionalNavigationParameters] Additional navigation parameters configured in the crossAppNavigation outbound parameters.
+     */;
+    _proto.navigate = function navigate(sSemanticObject, sAction, mNavigationParameters) {
+      const _doNavigate = oContext => {
+        const vNavigationContexts = mNavigationParameters && mNavigationParameters.navigationContexts,
+          aNavigationContexts = vNavigationContexts && !Array.isArray(vNavigationContexts) ? [vNavigationContexts] : vNavigationContexts,
+          vSemanticObjectMapping = mNavigationParameters && mNavigationParameters.semanticObjectMapping,
+          vOutboundParams = mNavigationParameters && mNavigationParameters.additionalNavigationParameters,
+          oTargetInfo = {
+            semanticObject: sSemanticObject,
+            action: sAction
+          },
+          oView = this.base.getView(),
+          oController = oView.getController();
+        if (oContext) {
+          this._oView.setBindingContext(oContext);
+        }
+        if (sSemanticObject && sAction) {
+          let aSemanticAttributes = [],
+            oSelectionVariant = new SelectionVariant();
+          // 1. get SemanticAttributes for navigation
+          if (aNavigationContexts && aNavigationContexts.length) {
+            aNavigationContexts.forEach(oNavigationContext => {
+              // 1.1.a if navigation context is instance of sap.ui.mode.odata.v4.Context
+              // else check if navigation context is of type object
+              if (oNavigationContext.isA && oNavigationContext.isA("sap.ui.model.odata.v4.Context")) {
+                // 1.1.b remove sensitive data
+                let oSemanticAttributes = oNavigationContext.getObject();
+                const sMetaPath = this._oMetaModel.getMetaPath(oNavigationContext.getPath());
+                // TODO: also remove sensitive data from  navigation properties
+                oSemanticAttributes = this.removeSensitiveData(oSemanticAttributes, sMetaPath);
+                const oNavContext = this.prepareContextForExternalNavigation(oSemanticAttributes, oNavigationContext);
+                oTargetInfo["propertiesWithoutConflict"] = oNavContext.propertiesWithoutConflict;
+                aSemanticAttributes.push(oNavContext.semanticAttributes);
+              } else if (!(oNavigationContext && Array.isArray(oNavigationContext.data)) && typeof oNavigationContext === "object") {
+                // 1.1.b remove sensitive data from object
+                aSemanticAttributes.push(this.removeSensitiveData(oNavigationContext.data, oNavigationContext.metaPath));
+              } else if (oNavigationContext && Array.isArray(oNavigationContext.data)) {
+                // oNavigationContext.data can be array already ex : [{Customer: "10001"}, {Customer: "10091"}]
+                // hence assigning it to the aSemanticAttributes
+                aSemanticAttributes = this.removeSensitiveData(oNavigationContext.data, oNavigationContext.metaPath);
+              }
+            });
+          }
+          // 2.1 Merge base selection variant and sanitized semantic attributes into one SelectionVariant
+          if (aSemanticAttributes && aSemanticAttributes.length) {
+            oSelectionVariant = this._oNavigationService.mixAttributesAndSelectionVariant(aSemanticAttributes, oSelectionVariant.toJSONString());
+          }
+
+          // 3. Add filterContextUrl to SV so the NavigationHandler can remove any sensitive data based on view entitySet
+          const oModel = this._oView.getModel(),
+            sEntitySet = this.getEntitySet(),
+            sContextUrl = sEntitySet ? this._oNavigationService.constructContextUrl(sEntitySet, oModel) : undefined;
+          if (sContextUrl) {
+            oSelectionVariant.setFilterContextUrl(sContextUrl);
+          }
+
+          // Apply Outbound Parameters to the SV
+          if (vOutboundParams) {
+            this._applyOutboundParams(oSelectionVariant, vOutboundParams);
+          }
+
+          // 4. give an opportunity for the application to influence the SelectionVariant
+          oController.intentBasedNavigation.adaptNavigationContext(oSelectionVariant, oTargetInfo);
+
+          // 5. Apply semantic object mappings to the SV
+          if (vSemanticObjectMapping) {
+            this._applySemanticObjectMappings(oSelectionVariant, vSemanticObjectMapping);
+          }
+
+          // 6. remove technical parameters from Selection Variant
+          this._removeTechnicalParameters(oSelectionVariant);
+
+          // 7. check if programming model is sticky and page is editable
+          const sNavMode = oController._intentBasedNavigation.getNavigationMode();
+
+          // 8. Updating refresh strategy in internal model
+          const mRefreshStrategies = mNavigationParameters && mNavigationParameters.refreshStrategies || {},
+            oInternalModel = oView.getModel("internal");
+          if (oInternalModel) {
+            if ((oView && oView.getViewData()).refreshStrategyOnAppRestore) {
+              const mViewRefreshStrategies = oView.getViewData().refreshStrategyOnAppRestore || {};
+              mergeObjects(mRefreshStrategies, mViewRefreshStrategies);
+            }
+            const mRefreshStrategy = KeepAliveHelper.getRefreshStrategyForIntent(mRefreshStrategies, sSemanticObject, sAction);
+            if (mRefreshStrategy) {
+              oInternalModel.setProperty("/refreshStrategyOnAppRestore", mRefreshStrategy);
+            }
+          }
+
+          // 9. Navigate via NavigationHandler
+          const onError = function () {
+            sap.ui.require(["sap/m/MessageBox"], function (MessageBox) {
+              const oResourceBundle = Core.getLibraryResourceBundle("sap.fe.core");
+              MessageBox.error(oResourceBundle.getText("C_COMMON_HELPER_NAVIGATION_ERROR_MESSAGE"), {
+                title: oResourceBundle.getText("C_COMMON_SAPFE_ERROR")
+              });
+            });
+          };
+          this._oNavigationService.navigate(sSemanticObject, sAction, oSelectionVariant.toJSONString(), undefined, onError, undefined, sNavMode);
+        } else {
+          throw new Error("Semantic Object/action is not provided");
+        }
+      };
+      const oBindingContext = this.base.getView().getBindingContext();
+      const oMetaModel = oBindingContext && oBindingContext.getModel().getMetaModel();
+      if (this.getView().getViewData().converterType === "ObjectPage" && oMetaModel && !ModelHelper.isStickySessionSupported(oMetaModel)) {
+        draft.processDataLossOrDraftDiscardConfirmation(_doNavigate.bind(this), Function.prototype, this.base.getView().getBindingContext(), this.base.getView().getController(), true, draft.NavigationType.ForwardNavigation);
+      } else {
+        _doNavigate();
+      }
+    }
+
+    /**
+     * Prepare attributes to be passed to external navigation.
+     *
+     * @param oSemanticAttributes Context data after removing all sensitive information.
+     * @param oContext Actual context from which the semanticAttributes were derived.
+     * @returns Object of prepared attributes for external navigation and no conflict properties.
+     */;
+    _proto.prepareContextForExternalNavigation = function prepareContextForExternalNavigation(oSemanticAttributes, oContext) {
+      // 1. Find all distinct keys in the object SemanticAttributes
+      // Store meta path for each occurence of the key
+      const oDistinctKeys = {},
+        sContextPath = oContext.getPath(),
+        oMetaModel = oContext.getModel().getMetaModel(),
+        sMetaPath = oMetaModel.getMetaPath(sContextPath),
+        aMetaPathParts = sMetaPath.split("/").filter(Boolean);
+      function _findDistinctKeysInObject(LookUpObject, sLookUpObjectMetaPath) {
+        for (const sKey in LookUpObject) {
+          // null case??
+          if (LookUpObject[sKey] === null || typeof LookUpObject[sKey] !== "object") {
+            if (!oDistinctKeys[sKey]) {
+              // if key is found for the first time then create array
+              oDistinctKeys[sKey] = [];
+            }
+            // push path to array
+            oDistinctKeys[sKey].push(sLookUpObjectMetaPath);
+          } else {
+            // if a nested object is found
+            const oNewLookUpObject = LookUpObject[sKey];
+            _findDistinctKeysInObject(oNewLookUpObject, `${sLookUpObjectMetaPath}/${sKey}`);
+          }
+        }
+      }
+      _findDistinctKeysInObject(oSemanticAttributes, sMetaPath);
+
+      // 2. Determine distinct key value and add conflicted paths to semantic attributes
+      const sMainEntitySetName = aMetaPathParts[0],
+        sMainEntityTypeName = oMetaModel.getObject(`/${sMainEntitySetName}/@sapui.name`),
+        oPropertiesWithoutConflict = {};
+      let sMainEntityValuePath, sCurrentValuePath, sLastValuePath;
+      for (const sDistinctKey in oDistinctKeys) {
+        const aConflictingPaths = oDistinctKeys[sDistinctKey];
+        let sWinnerValuePath;
+        // Find winner value for each distinct key in case of conflict by the following rule:
+
+        // -> A. if any meta path for a distinct key is the same as main entity take that as the value
+        // -> B. if A is not met keep the value from the current context (sMetaPath === path of distince key)
+        // -> C. if A, B or C are not met take the last path for value
+        if (aConflictingPaths.length > 1) {
+          // conflict
+          for (let i = 0; i <= aConflictingPaths.length - 1; i++) {
+            const sPath = aConflictingPaths[i];
+            let sPathInContext = sPath.replace(sPath === sMetaPath ? sMetaPath : `${sMetaPath}/`, "");
+            sPathInContext = (sPathInContext === "" ? sPathInContext : `${sPathInContext}/`) + sDistinctKey;
+            const sEntityTypeName = oMetaModel.getObject(`${sPath}/@sapui.name`);
+            // rule A
+
+            // rule A
+            if (sEntityTypeName === sMainEntityTypeName) {
+              sMainEntityValuePath = sPathInContext;
+            }
+
+            // rule B
+            if (sPath === sMetaPath) {
+              sCurrentValuePath = sPathInContext;
+            }
+
+            // rule C
+            sLastValuePath = sPathInContext;
+
+            // add conflicted path to semantic attributes
+            // check if the current path points to main entity and prefix attribute names accordingly
+            oSemanticAttributes[`${sMetaPath}/${sPathInContext}`.split("/").filter(function (sValue) {
+              return sValue != "";
+            }).join(".")] = oContext.getProperty(sPathInContext);
+          }
+          // A || B || C
+          sWinnerValuePath = sMainEntityValuePath || sCurrentValuePath || sLastValuePath;
+          oSemanticAttributes[sDistinctKey] = oContext.getProperty(sWinnerValuePath);
+          sMainEntityValuePath = undefined;
+          sCurrentValuePath = undefined;
+          sLastValuePath = undefined;
+        } else {
+          // no conflict, add distinct key without adding paths
+          const sPath = aConflictingPaths[0]; // because there is only one and hence no conflict
+          let sPathInContext = sPath.replace(sPath === sMetaPath ? sMetaPath : `${sMetaPath}/`, "");
+          sPathInContext = (sPathInContext === "" ? sPathInContext : `${sPathInContext}/`) + sDistinctKey;
+          oSemanticAttributes[sDistinctKey] = oContext.getProperty(sPathInContext);
+          oPropertiesWithoutConflict[sDistinctKey] = `${sMetaPath}/${sPathInContext}`.split("/").filter(function (sValue) {
+            return sValue != "";
+          }).join(".");
+        }
+      }
+      // 3. Remove all Navigation properties
+      for (const sProperty in oSemanticAttributes) {
+        if (oSemanticAttributes[sProperty] !== null && typeof oSemanticAttributes[sProperty] === "object") {
+          delete oSemanticAttributes[sProperty];
+        }
+      }
+      return {
+        semanticAttributes: oSemanticAttributes,
+        propertiesWithoutConflict: oPropertiesWithoutConflict
+      };
+    }
+    /**
+     * Prepare filter conditions to be passed to external navigation.
+     *
+     * @param oFilterBarConditions Filter conditions.
+     * @param sRootPath Root path of the application.
+     * @param aParameters Names of parameters to be considered.
+     * @returns Object of prepared filter conditions for external navigation and no conflict filters.
+     */;
+    _proto.prepareFiltersForExternalNavigation = function prepareFiltersForExternalNavigation(oFilterBarConditions, sRootPath, aParameters) {
+      let sPath;
+      const oDistinctKeys = {};
+      const oFilterConditionsWithoutConflict = {};
+      let sMainEntityValuePath, sCurrentValuePath, sFullContextPath, sWinnerValuePath, sPathInContext;
+      function _findDistinctKeysInObject(LookUpObject) {
+        let sLookUpObjectMetaPath;
+        for (let sKey in LookUpObject) {
+          if (LookUpObject[sKey]) {
+            if (sKey.includes("/")) {
+              sLookUpObjectMetaPath = sKey; // "/SalesOrdermanage/_Item/Material"
+              const aPathParts = sKey.split("/");
+              sKey = aPathParts[aPathParts.length - 1];
+            } else {
+              sLookUpObjectMetaPath = sRootPath;
+            }
+            if (!oDistinctKeys[sKey]) {
+              // if key is found for the first time then create array
+              oDistinctKeys[sKey] = [];
+            }
+
+            // push path to array
+            oDistinctKeys[sKey].push(sLookUpObjectMetaPath);
+          }
+        }
+      }
+      _findDistinctKeysInObject(oFilterBarConditions);
+      for (const sDistinctKey in oDistinctKeys) {
+        const aConflictingPaths = oDistinctKeys[sDistinctKey];
+        if (aConflictingPaths.length > 1) {
+          // conflict
+          for (let i = 0; i <= aConflictingPaths.length - 1; i++) {
+            sPath = aConflictingPaths[i];
+            if (sPath === sRootPath) {
+              sFullContextPath = `${sRootPath}/${sDistinctKey}`;
+              sPathInContext = sDistinctKey;
+              sMainEntityValuePath = sDistinctKey;
+              if (aParameters && aParameters.includes(sDistinctKey)) {
+                oFilterBarConditions[`$Parameter.${sDistinctKey}`] = oFilterBarConditions[sDistinctKey];
+              }
+            } else {
+              sPathInContext = sPath;
+              sFullContextPath = `${sRootPath}/${sPath}`.replaceAll(/\*/g, "");
+              sCurrentValuePath = sPath;
+            }
+            oFilterBarConditions[sFullContextPath.split("/").filter(function (sValue) {
+              return sValue != "";
+            }).join(".")] = oFilterBarConditions[sPathInContext];
+            delete oFilterBarConditions[sPath];
+          }
+          sWinnerValuePath = sMainEntityValuePath || sCurrentValuePath;
+          oFilterBarConditions[sDistinctKey] = oFilterBarConditions[sWinnerValuePath];
+        } else {
+          // no conflict, add distinct key without adding paths
+          sPath = aConflictingPaths[0];
+          sFullContextPath = sPath === sRootPath ? `${sRootPath}/${sDistinctKey}` : `${sRootPath}/${sPath}`.replaceAll("*", "");
+          oFilterConditionsWithoutConflict[sDistinctKey] = sFullContextPath.split("/").filter(function (sValue) {
+            return sValue != "";
+          }).join(".");
+          if (aParameters && aParameters.includes(sDistinctKey)) {
+            oFilterBarConditions[`$Parameter.${sDistinctKey}`] = oFilterBarConditions[sDistinctKey];
+          }
+        }
+      }
+      return {
+        filterConditions: oFilterBarConditions,
+        filterConditionsWithoutConflict: oFilterConditionsWithoutConflict
+      };
+    }
+
+    /**
+     * Get Navigation mode.
+     *
+     * @returns The navigation mode
+     */;
+    _proto.getNavigationMode = function getNavigationMode() {
+      return undefined;
+    }
+    /**
+     * Allows for navigation to a given intent (SemanticObject-Action) with the provided context, using a dialog that shows the contexts which cannot be passed
+     * If semantic object mapping is provided, this setting is also applied to the selection variant after adaptation by a consumer.
+     * This setting also removes any technical parameters and determines if an inplace or explace navigation should take place.
+     *
+     * @param sSemanticObject Semantic object for the target app
+     * @param sAction  Action for the target app
+     * @param [mNavigationParameters] Optional parameters to be passed to the external navigation
+     * @param [mNavigationParameters.label]
+     * @param [mNavigationParameters.navigationContexts] Single instance or multiple instances of {@link sap.ui.model.odata.v4.Context}, or alternatively an object or array of objects, to be passed to the intent.
+     * @param [mNavigationParameters.applicableContexts] Single instance or multiple instances of {@link sap.ui.model.odata.v4.Context}, or alternatively an object or array of objects, to be passed to the intent and for which the IBN button is enabled
+     * @param [mNavigationParameters.notApplicableContexts] Single instance or multiple instances of {@link sap.ui.model.odata.v4.Context}, or alternatively an object or array of objects, which cannot be passed to the intent.
+     *		  if an array of contexts is passed the context is used to determine the meta path and accordingly remove the sensitive data
+     *		  If an array of objects is passed, the following format is expected:
+     *		  {
+     *			data: {
+     *	 			ProductID: 7634,
+     *				Name: "Laptop"
+     *			 },
+     *			 metaPath: "/SalesOrderManage"
+     *        }
+     *		The metaPath is used to remove any sensitive data.
+     * @param [mNavigationParameters.semanticObjectMapping] String representation of SemanticObjectMapping or SemanticObjectMapping that applies to this navigation
+     */;
+    _proto.navigateWithConfirmationDialog = function navigateWithConfirmationDialog(sSemanticObject, sAction, mNavigationParameters) {
+      var _mNavigationParameter;
+      if (mNavigationParameters !== null && mNavigationParameters !== void 0 && mNavigationParameters.notApplicableContexts && ((_mNavigationParameter = mNavigationParameters.notApplicableContexts) === null || _mNavigationParameter === void 0 ? void 0 : _mNavigationParameter.length) >= 1) {
+        let oApplicableContextDialog;
+        const oController = {
+          onClose: function () {
+            // User cancels action
+            oApplicableContextDialog.close();
+          },
+          onContinue: () => {
+            // Users continues the action with the bound contexts
+            mNavigationParameters.navigationContexts = mNavigationParameters.applicableContexts;
+            oApplicableContextDialog.close();
+            this.navigate(sSemanticObject, sAction, mNavigationParameters);
+          }
+        };
+        const fnOpenAndFillDialog = function () {
+          let oDialogContent;
+          const nNotApplicable = mNavigationParameters.notApplicableContexts.length,
+            aNotApplicableItems = [];
+          for (let i = 0; i < mNavigationParameters.notApplicableContexts.length; i++) {
+            oDialogContent = mNavigationParameters.notApplicableContexts[i].getObject();
+            aNotApplicableItems.push(oDialogContent);
+          }
+          const oNotApplicableItemsModel = new JSONModel(aNotApplicableItems);
+          const oTotals = new JSONModel({
+            total: nNotApplicable,
+            label: mNavigationParameters.label
+          });
+          oApplicableContextDialog.setModel(oNotApplicableItemsModel, "notApplicable");
+          oApplicableContextDialog.setModel(oTotals, "totals");
+          oApplicableContextDialog.open();
+        };
+        // Show the contexts that are not applicable and will not therefore be processed
+        const sFragmentName = "sap.fe.core.controls.ActionPartial";
+        const oDialogFragment = XMLTemplateProcessor.loadTemplate(sFragmentName, "fragment");
+        const oModel = this._oView.getModel();
+        const oMetaModel = oModel.getMetaModel();
+        const sCanonicalPath = mNavigationParameters.notApplicableContexts[0].getCanonicalPath();
+        const sEntitySet = `${sCanonicalPath.substr(0, sCanonicalPath.indexOf("("))}/`;
+        Promise.resolve(XMLPreprocessor.process(oDialogFragment, {
+          name: sFragmentName
+        }, {
+          bindingContexts: {
+            entityType: oMetaModel.createBindingContext(sEntitySet)
+          },
+          models: {
+            entityType: oMetaModel,
+            metaModel: oMetaModel
+          }
+        })).then(function (oFragment) {
+          return Fragment.load({
+            definition: oFragment,
+            controller: oController
+          });
+        }).then(oPopover => {
+          oApplicableContextDialog = oPopover;
+          this.getView().addDependent(oPopover);
+          fnOpenAndFillDialog();
+        }).catch(function () {
+          Log.error("Error");
+        });
+      } else {
+        this.navigate(sSemanticObject, sAction, mNavigationParameters);
+      }
+    };
+    _proto._removeTechnicalParameters = function _removeTechnicalParameters(oSelectionVariant) {
+      oSelectionVariant.removeSelectOption("@odata.context");
+      oSelectionVariant.removeSelectOption("@odata.metadataEtag");
+      oSelectionVariant.removeSelectOption("SAP__Messages");
+    }
+    /**
+     * Get targeted Entity set.
+     *
+     * @returns Entity set name
+     */;
+    _proto.getEntitySet = function getEntitySet() {
+      return this._oView.getViewData().entitySet;
+    }
+    /**
+     * Removes sensitive data from the semantic attribute with respect to the entitySet.
+     *
+     * @param oAttributes Context data
+     * @param sMetaPath Meta path to reach the entitySet in the MetaModel
+     * @returns Array of semantic Attributes
+     * @private
+     */
+    // TO-DO add unit tests for this function in the controller extension qunit.
+    ;
+    _proto.removeSensitiveData = function removeSensitiveData(oAttributes, sMetaPath) {
+      if (oAttributes) {
+        const {
+          transAggregations,
+          customAggregates
+        } = this._getAggregates(sMetaPath, this.base.getView(), this.base.getAppComponent().getDiagnostics());
+        const aProperties = Object.keys(oAttributes);
+        if (aProperties.length) {
+          delete oAttributes["@odata.context"];
+          delete oAttributes["@odata.metadataEtag"];
+          delete oAttributes["SAP__Messages"];
+          for (let j = 0; j < aProperties.length; j++) {
+            if (oAttributes[aProperties[j]] && typeof oAttributes[aProperties[j]] === "object") {
+              this.removeSensitiveData(oAttributes[aProperties[j]], `${sMetaPath}/${aProperties[j]}`);
+            }
+            const sProp = aProperties[j];
+            if (sProp.indexOf("@odata.type") > -1) {
+              delete oAttributes[aProperties[j]];
+              continue;
+            }
+            this._deleteAggregates([...transAggregations, ...customAggregates], aProperties[j], oAttributes);
+            const aPropertyAnnotations = this._getPropertyAnnotations(sProp, sMetaPath, oAttributes, this._oMetaModel);
+            if (aPropertyAnnotations) {
+              if (aPropertyAnnotations["com.sap.vocabularies.PersonalData.v1.IsPotentiallySensitive"] || aPropertyAnnotations["com.sap.vocabularies.UI.v1.ExcludeFromNavigationContext"] || aPropertyAnnotations["com.sap.vocabularies.Analytics.v1.Measure"]) {
+                delete oAttributes[sProp];
+              } else if (aPropertyAnnotations["com.sap.vocabularies.Common.v1.FieldControl"]) {
+                const oFieldControl = aPropertyAnnotations["com.sap.vocabularies.Common.v1.FieldControl"];
+                if (oFieldControl["$EnumMember"] && oFieldControl["$EnumMember"].split("/")[1] === "Inapplicable") {
+                  delete oAttributes[sProp];
+                } else if (oFieldControl["$Path"] && this._isFieldControlPathInapplicable(oFieldControl["$Path"], oAttributes)) {
+                  delete oAttributes[sProp];
+                }
+              }
+            }
+          }
+        }
+      }
+      return oAttributes;
+    }
+
+    /**
+     * Remove the attribute from navigation data if it is a measure.
+     *
+     * @param aggregates Array of Aggregates
+     * @param sProp Attribute name
+     * @param oAttributes SemanticAttributes
+     */;
+    _proto._deleteAggregates = function _deleteAggregates(aggregates, sProp, oAttributes) {
+      if (aggregates && aggregates.indexOf(sProp) > -1) {
+        delete oAttributes[sProp];
+      }
+    }
+
+    /**
+     * Returns the property annotations.
+     *
+     * @param sProp
+     * @param sMetaPath
+     * @param oAttributes
+     * @param oMetaModel
+     * @returns - The property annotations
+     */;
+    _proto._getPropertyAnnotations = function _getPropertyAnnotations(sProp, sMetaPath, oAttributes, oMetaModel) {
+      if (oAttributes[sProp] && sMetaPath && !sMetaPath.includes("undefined")) {
+        var _oFullContext$targetO, _oFullContext$targetO2;
+        const oContext = oMetaModel.createBindingContext(`${sMetaPath}/${sProp}`);
+        const oFullContext = MetaModelConverter.getInvolvedDataModelObjects(oContext);
+        return oFullContext === null || oFullContext === void 0 ? void 0 : (_oFullContext$targetO = oFullContext.targetObject) === null || _oFullContext$targetO === void 0 ? void 0 : (_oFullContext$targetO2 = _oFullContext$targetO.annotations) === null || _oFullContext$targetO2 === void 0 ? void 0 : _oFullContext$targetO2._annotations;
+      }
+      return null;
+    }
+
+    /**
+     * Returns the aggregates part of the EntitySet or EntityType.
+     *
+     * @param sMetaPath
+     * @param oView
+     * @param oDiagnostics
+     * @returns - The aggregates
+     */;
+    _proto._getAggregates = function _getAggregates(sMetaPath, oView, oDiagnostics) {
+      const converterContext = this._getConverterContext(sMetaPath, oView, oDiagnostics);
+      const aggregationHelper = new AggregationHelper(converterContext.getEntityType(), converterContext);
+      const isAnalyticsSupported = aggregationHelper.isAnalyticsSupported();
+      let transAggregations = [],
+        customAggregates = [];
+      if (isAnalyticsSupported) {
+        transAggregations = aggregationHelper.getTransAggregations();
+        if (transAggregations.length) {
+          transAggregations = transAggregations.map(transAgg => {
+            return transAgg.Name || transAgg.Value;
+          });
+        }
+        customAggregates = aggregationHelper.getCustomAggregateDefinitions();
+        if (customAggregates.length) {
+          customAggregates = customAggregates.map(customAggregate => {
+            return customAggregate.qualifier;
+          });
+        }
+      }
+      return {
+        transAggregations,
+        customAggregates
+      };
+    }
+
+    /**
+     * Returns converterContext.
+     *
+     * @param sMetaPath
+     * @param oView
+     * @param oDiagnostics
+     * @returns - ConverterContext
+     */;
+    _proto._getConverterContext = function _getConverterContext(sMetaPath, oView, oDiagnostics) {
+      const oViewData = oView.getViewData();
+      let sEntitySet = oViewData.entitySet;
+      const sContextPath = oViewData.contextPath;
+      if (sContextPath && (!sEntitySet || sEntitySet.includes("/"))) {
+        sEntitySet = oViewData === null || oViewData === void 0 ? void 0 : oViewData.fullContextPath.split("/")[1];
+      }
+      return CommonUtils.getConverterContextForPath(sMetaPath, oView.getModel().getMetaModel(), sEntitySet, oDiagnostics);
+    }
+
+    /**
+     * Check if path-based FieldControl evaluates to inapplicable.
+     *
+     * @param sFieldControlPath Field control path
+     * @param oAttribute SemanticAttributes
+     * @returns `true` if inapplicable
+     */;
+    _proto._isFieldControlPathInapplicable = function _isFieldControlPathInapplicable(sFieldControlPath, oAttribute) {
+      let bInapplicable = false;
+      const aParts = sFieldControlPath.split("/");
+      // sensitive data is removed only if the path has already been resolved.
+      if (aParts.length > 1) {
+        bInapplicable = oAttribute[aParts[0]] && oAttribute[aParts[0]].hasOwnProperty(aParts[1]) && oAttribute[aParts[0]][aParts[1]] === 0;
+      } else {
+        bInapplicable = oAttribute[sFieldControlPath] === 0;
+      }
+      return bInapplicable;
+    }
+    /**
+     * Method to replace Local Properties with Semantic Object mappings.
+     *
+     * @param oSelectionVariant SelectionVariant consisting of filterbar, Table and Page Context
+     * @param vMappings A string representation of semantic object mapping
+     * @returns - Modified SelectionVariant with LocalProperty replaced with SemanticObjectProperties.
+     */;
+    _proto._applySemanticObjectMappings = function _applySemanticObjectMappings(oSelectionVariant, vMappings) {
+      const oMappings = typeof vMappings === "string" ? JSON.parse(vMappings) : vMappings;
+      for (let i = 0; i < oMappings.length; i++) {
+        const sLocalProperty = oMappings[i]["LocalProperty"] && oMappings[i]["LocalProperty"]["$PropertyPath"] || oMappings[i]["@com.sap.vocabularies.Common.v1.LocalProperty"] && oMappings[i]["@com.sap.vocabularies.Common.v1.LocalProperty"]["$Path"];
+        const sSemanticObjectProperty = oMappings[i]["SemanticObjectProperty"] || oMappings[i]["@com.sap.vocabularies.Common.v1.SemanticObjectProperty"];
+        const oSelectOption = oSelectionVariant.getSelectOption(sLocalProperty);
+        if (oSelectOption) {
+          //Create a new SelectOption with sSemanticObjectProperty as the property Name and remove the older one
+          oSelectionVariant.removeSelectOption(sLocalProperty);
+          oSelectionVariant.massAddSelectOption(sSemanticObjectProperty, oSelectOption);
+        }
+      }
+      return oSelectionVariant;
+    }
+    /**
+     * Navigates to an Outbound provided in the manifest.
+     *
+     * @function
+     * @param sOutbound Identifier to location the outbound in the manifest
+     * @param mNavigationParameters Optional map containing key/value pairs to be passed to the intent
+     * @alias sap.fe.core.controllerextensions.IntentBasedNavigation#navigateOutbound
+     * @since 1.86.0
+     */;
+    _proto.navigateOutbound = function navigateOutbound(sOutbound, mNavigationParameters) {
+      var _oManifestEntry$cross, _oManifestEntry$cross2;
+      let aNavParams;
+      const oManifestEntry = this.base.getAppComponent().getManifestEntry("sap.app"),
+        oOutbound = (_oManifestEntry$cross = oManifestEntry.crossNavigation) === null || _oManifestEntry$cross === void 0 ? void 0 : (_oManifestEntry$cross2 = _oManifestEntry$cross.outbounds) === null || _oManifestEntry$cross2 === void 0 ? void 0 : _oManifestEntry$cross2[sOutbound];
+      if (!oOutbound) {
+        Log.error("Outbound is not defined in manifest!!");
+        return;
+      }
+      const sSemanticObject = oOutbound.semanticObject,
+        sAction = oOutbound.action,
+        outboundParams = oOutbound.parameters && this.getOutboundParams(oOutbound.parameters);
+      if (mNavigationParameters) {
+        aNavParams = [];
+        Object.keys(mNavigationParameters).forEach(function (key) {
+          let oParams;
+          if (Array.isArray(mNavigationParameters[key])) {
+            const aValues = mNavigationParameters[key];
+            for (let i = 0; i < aValues.length; i++) {
+              var _aNavParams;
+              oParams = {};
+              oParams[key] = aValues[i];
+              (_aNavParams = aNavParams) === null || _aNavParams === void 0 ? void 0 : _aNavParams.push(oParams);
+            }
+          } else {
+            var _aNavParams2;
+            oParams = {};
+            oParams[key] = mNavigationParameters[key];
+            (_aNavParams2 = aNavParams) === null || _aNavParams2 === void 0 ? void 0 : _aNavParams2.push(oParams);
+          }
+        });
+      }
+      if (aNavParams || outboundParams) {
+        mNavigationParameters = {
+          navigationContexts: {
+            data: aNavParams || outboundParams
+          }
+        };
+      }
+      this.base._intentBasedNavigation.navigate(sSemanticObject, sAction, mNavigationParameters);
+    }
+
+    /**
+     * Method to apply outbound parameters defined in the manifest.
+     *
+     * @param oSelectionVariant SelectionVariant consisting of a filter bar, a table, and a page context
+     * @param vOutboundParams Outbound Properties defined in the manifest
+     * @returns - The modified SelectionVariant with outbound parameters.
+     */;
+    _proto._applyOutboundParams = function _applyOutboundParams(oSelectionVariant, vOutboundParams) {
+      const aParameters = Object.keys(vOutboundParams);
+      const aSelectProperties = oSelectionVariant.getSelectOptionsPropertyNames();
+      aParameters.forEach(function (key) {
+        if (!aSelectProperties.includes(key)) {
+          oSelectionVariant.addSelectOption(key, "I", "EQ", vOutboundParams[key]);
+        }
+      });
+      return oSelectionVariant;
+    }
+    /**
+     * Method to get the outbound parameters defined in the manifest.
+     *
+     * @function
+     * @param oOutboundParams Parameters defined in the outbounds. Only "plain" is supported
+     * @returns Parameters with the key-Value pair
+     */;
+    _proto.getOutboundParams = function getOutboundParams(oOutboundParams) {
+      const oParamsMapping = {};
+      if (oOutboundParams) {
+        const aParameters = Object.keys(oOutboundParams) || [];
+        if (aParameters.length > 0) {
+          aParameters.forEach(function (key) {
+            const oMapping = oOutboundParams[key];
+            if (oMapping.value && oMapping.value.value && oMapping.value.format === "plain") {
+              if (!oParamsMapping[key]) {
+                oParamsMapping[key] = oMapping.value.value;
+              }
+            }
+          });
+        }
+      }
+      return oParamsMapping;
+    }
+
+    /**
+     * Triggers an outbound navigation when a user chooses the chevron.
+     *
+     * @param {object} oController
+     * @param {string} sOutboundTarget Name of the outbound target (needs to be defined in the manifest)
+     * @param {sap.ui.model.odata.v4.Context} oContext The context that contains the data for the target app
+     * @param {string} sCreatePath Create path when the chevron is created.
+     * @returns {Promise} Promise which is resolved once the navigation is triggered
+     */;
+    _proto.onChevronPressNavigateOutBound = function onChevronPressNavigateOutBound(oController, sOutboundTarget, oContext, sCreatePath) {
+      const oOutbounds = oController.getAppComponent().getRoutingService().getOutbounds();
+      const oDisplayOutbound = oOutbounds[sOutboundTarget];
+      let additionalNavigationParameters;
+      if (oDisplayOutbound && oDisplayOutbound.semanticObject && oDisplayOutbound.action) {
+        const oRefreshStrategies = {
+          intents: {}
+        };
+        const oDefaultRefreshStrategy = {};
+        let sMetaPath;
+        if (oContext) {
+          if (oContext.isA && oContext.isA("sap.ui.model.odata.v4.Context")) {
+            sMetaPath = ModelHelper.getMetaPathForContext(oContext);
+            oContext = [oContext];
+          } else {
+            sMetaPath = ModelHelper.getMetaPathForContext(oContext[0]);
+          }
+          oDefaultRefreshStrategy[sMetaPath] = "self";
+          oRefreshStrategies["_feDefault"] = oDefaultRefreshStrategy;
+        }
+        if (sCreatePath) {
+          const sKey = `${oDisplayOutbound.semanticObject}-${oDisplayOutbound.action}`;
+          oRefreshStrategies.intents[sKey] = {};
+          oRefreshStrategies.intents[sKey][sCreatePath] = "self";
+        }
+        if (oDisplayOutbound && oDisplayOutbound.parameters) {
+          const oParams = oDisplayOutbound.parameters && this.getOutboundParams(oDisplayOutbound.parameters);
+          if (Object.keys(oParams).length > 0) {
+            additionalNavigationParameters = oParams;
+          }
+        }
+        oController._intentBasedNavigation.navigate(oDisplayOutbound.semanticObject, oDisplayOutbound.action, {
+          navigationContexts: oContext,
+          refreshStrategies: oRefreshStrategies,
+          additionalNavigationParameters: additionalNavigationParameters
+        });
+
+        //TODO: check why returning a promise is required
+        return Promise.resolve();
+      } else {
+        throw new Error(`outbound target ${sOutboundTarget} not found in cross navigation definition of manifest`);
+      }
+    };
+    return InternalIntentBasedNavigation;
+  }(ControllerExtension), (_applyDecoratedDescriptor(_class2.prototype, "onInit", [_dec2], Object.getOwnPropertyDescriptor(_class2.prototype, "onInit"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "navigate", [_dec3, _dec4], Object.getOwnPropertyDescriptor(_class2.prototype, "navigate"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "prepareContextForExternalNavigation", [_dec5, _dec6], Object.getOwnPropertyDescriptor(_class2.prototype, "prepareContextForExternalNavigation"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "prepareFiltersForExternalNavigation", [_dec7, _dec8], Object.getOwnPropertyDescriptor(_class2.prototype, "prepareFiltersForExternalNavigation"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "getNavigationMode", [_dec9, _dec10], Object.getOwnPropertyDescriptor(_class2.prototype, "getNavigationMode"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "navigateWithConfirmationDialog", [_dec11, _dec12], Object.getOwnPropertyDescriptor(_class2.prototype, "navigateWithConfirmationDialog"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "getEntitySet", [_dec13], Object.getOwnPropertyDescriptor(_class2.prototype, "getEntitySet"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "removeSensitiveData", [_dec14, _dec15], Object.getOwnPropertyDescriptor(_class2.prototype, "removeSensitiveData"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "navigateOutbound", [_dec16, _dec17], Object.getOwnPropertyDescriptor(_class2.prototype, "navigateOutbound"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "getOutboundParams", [_dec18, _dec19], Object.getOwnPropertyDescriptor(_class2.prototype, "getOutboundParams"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onChevronPressNavigateOutBound", [_dec20, _dec21], Object.getOwnPropertyDescriptor(_class2.prototype, "onChevronPressNavigateOutBound"), _class2.prototype)), _class2)) || _class);
+  return InternalIntentBasedNavigation;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["InternalIntentBasedNavigation","defineUI5Class","methodOverride","publicExtension","finalExtension","extensible","OverrideExecution","Instead","privateExtension","onInit","_oAppComponent","base","getAppComponent","_oMetaModel","getModel","getMetaModel","_oNavigationService","getNavigationService","_oView","getView","navigate","sSemanticObject","sAction","mNavigationParameters","_doNavigate","oContext","vNavigationContexts","navigationContexts","aNavigationContexts","Array","isArray","vSemanticObjectMapping","semanticObjectMapping","vOutboundParams","additionalNavigationParameters","oTargetInfo","semanticObject","action","oView","oController","getController","setBindingContext","aSemanticAttributes","oSelectionVariant","SelectionVariant","length","forEach","oNavigationContext","isA","oSemanticAttributes","getObject","sMetaPath","getMetaPath","getPath","removeSensitiveData","oNavContext","prepareContextForExternalNavigation","propertiesWithoutConflict","push","semanticAttributes","data","metaPath","mixAttributesAndSelectionVariant","toJSONString","oModel","sEntitySet","getEntitySet","sContextUrl","constructContextUrl","undefined","setFilterContextUrl","_applyOutboundParams","intentBasedNavigation","adaptNavigationContext","_applySemanticObjectMappings","_removeTechnicalParameters","sNavMode","_intentBasedNavigation","getNavigationMode","mRefreshStrategies","refreshStrategies","oInternalModel","getViewData","refreshStrategyOnAppRestore","mViewRefreshStrategies","mergeObjects","mRefreshStrategy","KeepAliveHelper","getRefreshStrategyForIntent","setProperty","onError","sap","ui","require","MessageBox","oResourceBundle","Core","getLibraryResourceBundle","error","getText","title","Error","oBindingContext","getBindingContext","oMetaModel","converterType","ModelHelper","isStickySessionSupported","draft","processDataLossOrDraftDiscardConfirmation","bind","Function","prototype","NavigationType","ForwardNavigation","oDistinctKeys","sContextPath","aMetaPathParts","split","filter","Boolean","_findDistinctKeysInObject","LookUpObject","sLookUpObjectMetaPath","sKey","oNewLookUpObject","sMainEntitySetName","sMainEntityTypeName","oPropertiesWithoutConflict","sMainEntityValuePath","sCurrentValuePath","sLastValuePath","sDistinctKey","aConflictingPaths","sWinnerValuePath","i","sPath","sPathInContext","replace","sEntityTypeName","sValue","join","getProperty","sProperty","prepareFiltersForExternalNavigation","oFilterBarConditions","sRootPath","aParameters","oFilterConditionsWithoutConflict","sFullContextPath","includes","aPathParts","replaceAll","filterConditions","filterConditionsWithoutConflict","navigateWithConfirmationDialog","notApplicableContexts","oApplicableContextDialog","onClose","close","onContinue","applicableContexts","fnOpenAndFillDialog","oDialogContent","nNotApplicable","aNotApplicableItems","oNotApplicableItemsModel","JSONModel","oTotals","total","label","setModel","open","sFragmentName","oDialogFragment","XMLTemplateProcessor","loadTemplate","sCanonicalPath","getCanonicalPath","substr","indexOf","Promise","resolve","XMLPreprocessor","process","name","bindingContexts","entityType","createBindingContext","models","metaModel","then","oFragment","Fragment","load","definition","controller","oPopover","addDependent","catch","Log","removeSelectOption","entitySet","oAttributes","transAggregations","customAggregates","_getAggregates","getDiagnostics","aProperties","Object","keys","j","sProp","_deleteAggregates","aPropertyAnnotations","_getPropertyAnnotations","oFieldControl","_isFieldControlPathInapplicable","aggregates","oFullContext","MetaModelConverter","getInvolvedDataModelObjects","targetObject","annotations","_annotations","oDiagnostics","converterContext","_getConverterContext","aggregationHelper","AggregationHelper","getEntityType","isAnalyticsSupported","getTransAggregations","map","transAgg","Name","Value","getCustomAggregateDefinitions","customAggregate","qualifier","oViewData","contextPath","fullContextPath","CommonUtils","getConverterContextForPath","sFieldControlPath","oAttribute","bInapplicable","aParts","hasOwnProperty","vMappings","oMappings","JSON","parse","sLocalProperty","sSemanticObjectProperty","oSelectOption","getSelectOption","massAddSelectOption","navigateOutbound","sOutbound","aNavParams","oManifestEntry","getManifestEntry","oOutbound","crossNavigation","outbounds","outboundParams","parameters","getOutboundParams","key","oParams","aValues","aSelectProperties","getSelectOptionsPropertyNames","addSelectOption","oOutboundParams","oParamsMapping","oMapping","value","format","onChevronPressNavigateOutBound","sOutboundTarget","sCreatePath","oOutbounds","getRoutingService","getOutbounds","oDisplayOutbound","oRefreshStrategies","intents","oDefaultRefreshStrategy","getMetaPathForContext","ControllerExtension"],"sourceRoot":".","sources":["InternalIntentBasedNavigation.ts"],"sourcesContent":["import Log from \"sap/base/Log\";\nimport mergeObjects from \"sap/base/util/merge\";\nimport type AppComponent from \"sap/fe/core/AppComponent\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport draft from \"sap/fe/core/controllerextensions/editFlow/draft\";\nimport * as MetaModelConverter from \"sap/fe/core/converters/MetaModelConverter\";\nimport {\n\tdefineUI5Class,\n\textensible,\n\tfinalExtension,\n\tmethodOverride,\n\tprivateExtension,\n\tpublicExtension\n} from \"sap/fe/core/helpers/ClassSupport\";\nimport KeepAliveHelper from \"sap/fe/core/helpers/KeepAliveHelper\";\nimport ModelHelper from \"sap/fe/core/helpers/ModelHelper\";\nimport type PageController from \"sap/fe/core/PageController\";\nimport type { NavigationService } from \"sap/fe/core/services/NavigationServiceFactory\";\nimport Diagnostics from \"sap/fe/core/support/Diagnostics\";\nimport SelectionVariant from \"sap/fe/navigation/SelectionVariant\";\nimport type Dialog from \"sap/m/Dialog\";\nimport Core from \"sap/ui/core/Core\";\nimport Fragment from \"sap/ui/core/Fragment\";\nimport ControllerExtension from \"sap/ui/core/mvc/ControllerExtension\";\nimport OverrideExecution from \"sap/ui/core/mvc/OverrideExecution\";\nimport type View from \"sap/ui/core/mvc/View\";\nimport XMLPreprocessor from \"sap/ui/core/util/XMLPreprocessor\";\nimport XMLTemplateProcessor from \"sap/ui/core/XMLTemplateProcessor\";\nimport type Context from \"sap/ui/model/Context\";\nimport JSONModel from \"sap/ui/model/json/JSONModel\";\nimport type ODataV4Context from \"sap/ui/model/odata/v4/Context\";\nimport type ODataMetaModel from \"sap/ui/model/odata/v4/ODataMetaModel\";\nimport { AggregationHelper } from \"../converters/helpers/Aggregation\";\n\n/**\n * {@link sap.ui.core.mvc.ControllerExtension Controller extension}\n *\n * @namespace\n * @alias sap.fe.core.controllerextensions.InternalInternalBasedNavigation\n * @private\n * @since 1.84.0\n */\n@defineUI5Class(\"sap.fe.core.controllerextensions.InternalInternalBasedNavigation\")\nclass InternalIntentBasedNavigation extends ControllerExtension {\n\tprotected base!: PageController;\n\tprivate _oAppComponent!: AppComponent;\n\tprivate _oMetaModel!: ODataMetaModel;\n\tprivate _oNavigationService!: NavigationService;\n\tprivate _oView!: View;\n\t@methodOverride()\n\tonInit() {\n\t\tthis._oAppComponent = this.base.getAppComponent();\n\t\tthis._oMetaModel = this._oAppComponent.getModel().getMetaModel() as ODataMetaModel;\n\t\tthis._oNavigationService = this._oAppComponent.getNavigationService();\n\t\tthis._oView = this.base.getView();\n\t}\n\n\t/**\n\t * Enables intent-based navigation (SemanticObject-Action) with the provided context.\n\t * If semantic object mapping is provided, this is also applied to the selection variant after the adaptation by a consumer.\n\t * This takes care of removing any technical parameters and determines if an explace or inplace navigation should take place.\n\t *\n\t * @param sSemanticObject Semantic object for the target app\n\t * @param sAction  Action for the target app\n\t * @param [mNavigationParameters] Optional parameters to be passed to the external navigation\n\t * @param [mNavigationParameters.navigationContexts] Uses one of the following to be passed to the intent:\n\t *    a single instance of {@link sap.ui.model.odata.v4.Context}\n\t *    multiple instances of {@link sap.ui.model.odata.v4.Context}\n\t *    an object or an array of objects\n\t *\t\t  If an array of objects is passed, the context is used to determine the metaPath and to remove any sensitive data\n\t *\t\t  If an array of objects is passed, the following format ix expected:\n\t *\t\t  {\n\t *\t\t\tdata: {\n\t *\t \t\t\tProductID: 7634,\n\t *\t\t\t\tName: \"Laptop\"\n\t *\t\t\t },\n\t *\t\t\t metaPath: \"/SalesOrderManage\"\n\t *        }\n\t * @param [mNavigationParameters.semanticObjectMapping] String representation of the SemanticObjectMapping or SemanticObjectMapping that applies to this navigation\n\t * @param [mNavigationParameters.defaultRefreshStrategy] Default refresh strategy to be used in case no refresh strategy is specified for the intent in the view.\n\t * @param [mNavigationParameters.refreshStrategies]\n\t * @param [mNavigationParameters.additionalNavigationParameters] Additional navigation parameters configured in the crossAppNavigation outbound parameters.\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tnavigate(\n\t\tsSemanticObject: string,\n\t\tsAction: string,\n\t\tmNavigationParameters:\n\t\t\t| {\n\t\t\t\t\tnavigationContexts?: object | any[] | undefined;\n\t\t\t\t\tsemanticObjectMapping?: string | object | undefined;\n\t\t\t\t\tdefaultRefreshStrategy?: object | undefined;\n\t\t\t\t\trefreshStrategies?: any;\n\t\t\t\t\tadditionalNavigationParameters?: object | undefined;\n\t\t\t  }\n\t\t\t| undefined\n\t) {\n\t\tconst _doNavigate = (oContext?: any) => {\n\t\t\tconst vNavigationContexts = mNavigationParameters && mNavigationParameters.navigationContexts,\n\t\t\t\taNavigationContexts =\n\t\t\t\t\tvNavigationContexts && !Array.isArray(vNavigationContexts) ? [vNavigationContexts] : vNavigationContexts,\n\t\t\t\tvSemanticObjectMapping = mNavigationParameters && mNavigationParameters.semanticObjectMapping,\n\t\t\t\tvOutboundParams = mNavigationParameters && mNavigationParameters.additionalNavigationParameters,\n\t\t\t\toTargetInfo: any = {\n\t\t\t\t\tsemanticObject: sSemanticObject,\n\t\t\t\t\taction: sAction\n\t\t\t\t},\n\t\t\t\toView = this.base.getView(),\n\t\t\t\toController = oView.getController() as PageController;\n\n\t\t\tif (oContext) {\n\t\t\t\tthis._oView.setBindingContext(oContext);\n\t\t\t}\n\n\t\t\tif (sSemanticObject && sAction) {\n\t\t\t\tlet aSemanticAttributes: any[] = [],\n\t\t\t\t\toSelectionVariant: any = new SelectionVariant();\n\t\t\t\t// 1. get SemanticAttributes for navigation\n\t\t\t\tif (aNavigationContexts && aNavigationContexts.length) {\n\t\t\t\t\taNavigationContexts.forEach((oNavigationContext: any) => {\n\t\t\t\t\t\t// 1.1.a if navigation context is instance of sap.ui.mode.odata.v4.Context\n\t\t\t\t\t\t// else check if navigation context is of type object\n\t\t\t\t\t\tif (oNavigationContext.isA && oNavigationContext.isA(\"sap.ui.model.odata.v4.Context\")) {\n\t\t\t\t\t\t\t// 1.1.b remove sensitive data\n\t\t\t\t\t\t\tlet oSemanticAttributes = oNavigationContext.getObject();\n\t\t\t\t\t\t\tconst sMetaPath = this._oMetaModel.getMetaPath(oNavigationContext.getPath());\n\t\t\t\t\t\t\t// TODO: also remove sensitive data from  navigation properties\n\t\t\t\t\t\t\toSemanticAttributes = this.removeSensitiveData(oSemanticAttributes, sMetaPath);\n\t\t\t\t\t\t\tconst oNavContext = this.prepareContextForExternalNavigation(oSemanticAttributes, oNavigationContext);\n\t\t\t\t\t\t\toTargetInfo[\"propertiesWithoutConflict\"] = oNavContext.propertiesWithoutConflict;\n\t\t\t\t\t\t\taSemanticAttributes.push(oNavContext.semanticAttributes);\n\t\t\t\t\t\t} else if (\n\t\t\t\t\t\t\t!(oNavigationContext && Array.isArray(oNavigationContext.data)) &&\n\t\t\t\t\t\t\ttypeof oNavigationContext === \"object\"\n\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t// 1.1.b remove sensitive data from object\n\t\t\t\t\t\t\taSemanticAttributes.push(this.removeSensitiveData(oNavigationContext.data, oNavigationContext.metaPath));\n\t\t\t\t\t\t} else if (oNavigationContext && Array.isArray(oNavigationContext.data)) {\n\t\t\t\t\t\t\t// oNavigationContext.data can be array already ex : [{Customer: \"10001\"}, {Customer: \"10091\"}]\n\t\t\t\t\t\t\t// hence assigning it to the aSemanticAttributes\n\t\t\t\t\t\t\taSemanticAttributes = this.removeSensitiveData(oNavigationContext.data, oNavigationContext.metaPath);\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\t// 2.1 Merge base selection variant and sanitized semantic attributes into one SelectionVariant\n\t\t\t\tif (aSemanticAttributes && aSemanticAttributes.length) {\n\t\t\t\t\toSelectionVariant = this._oNavigationService.mixAttributesAndSelectionVariant(\n\t\t\t\t\t\taSemanticAttributes,\n\t\t\t\t\t\toSelectionVariant.toJSONString()\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\t// 3. Add filterContextUrl to SV so the NavigationHandler can remove any sensitive data based on view entitySet\n\t\t\t\tconst oModel = this._oView.getModel(),\n\t\t\t\t\tsEntitySet = this.getEntitySet(),\n\t\t\t\t\tsContextUrl = sEntitySet ? this._oNavigationService.constructContextUrl(sEntitySet, oModel) : undefined;\n\t\t\t\tif (sContextUrl) {\n\t\t\t\t\toSelectionVariant.setFilterContextUrl(sContextUrl);\n\t\t\t\t}\n\n\t\t\t\t// Apply Outbound Parameters to the SV\n\t\t\t\tif (vOutboundParams) {\n\t\t\t\t\tthis._applyOutboundParams(oSelectionVariant, vOutboundParams);\n\t\t\t\t}\n\n\t\t\t\t// 4. give an opportunity for the application to influence the SelectionVariant\n\t\t\t\toController.intentBasedNavigation.adaptNavigationContext(oSelectionVariant, oTargetInfo);\n\n\t\t\t\t// 5. Apply semantic object mappings to the SV\n\t\t\t\tif (vSemanticObjectMapping) {\n\t\t\t\t\tthis._applySemanticObjectMappings(oSelectionVariant, vSemanticObjectMapping);\n\t\t\t\t}\n\n\t\t\t\t// 6. remove technical parameters from Selection Variant\n\t\t\t\tthis._removeTechnicalParameters(oSelectionVariant);\n\n\t\t\t\t// 7. check if programming model is sticky and page is editable\n\t\t\t\tconst sNavMode = oController._intentBasedNavigation.getNavigationMode();\n\n\t\t\t\t// 8. Updating refresh strategy in internal model\n\t\t\t\tconst mRefreshStrategies = (mNavigationParameters && mNavigationParameters.refreshStrategies) || {},\n\t\t\t\t\toInternalModel = oView.getModel(\"internal\") as JSONModel;\n\t\t\t\tif (oInternalModel) {\n\t\t\t\t\tif ((oView && (oView.getViewData() as any)).refreshStrategyOnAppRestore) {\n\t\t\t\t\t\tconst mViewRefreshStrategies = (oView.getViewData() as any).refreshStrategyOnAppRestore || {};\n\t\t\t\t\t\tmergeObjects(mRefreshStrategies, mViewRefreshStrategies);\n\t\t\t\t\t}\n\t\t\t\t\tconst mRefreshStrategy = KeepAliveHelper.getRefreshStrategyForIntent(mRefreshStrategies, sSemanticObject, sAction);\n\t\t\t\t\tif (mRefreshStrategy) {\n\t\t\t\t\t\toInternalModel.setProperty(\"/refreshStrategyOnAppRestore\", mRefreshStrategy);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// 9. Navigate via NavigationHandler\n\t\t\t\tconst onError = function () {\n\t\t\t\t\tsap.ui.require([\"sap/m/MessageBox\"], function (MessageBox: any) {\n\t\t\t\t\t\tconst oResourceBundle = Core.getLibraryResourceBundle(\"sap.fe.core\");\n\t\t\t\t\t\tMessageBox.error(oResourceBundle.getText(\"C_COMMON_HELPER_NAVIGATION_ERROR_MESSAGE\"), {\n\t\t\t\t\t\t\ttitle: oResourceBundle.getText(\"C_COMMON_SAPFE_ERROR\")\n\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t\t};\n\t\t\t\tthis._oNavigationService.navigate(\n\t\t\t\t\tsSemanticObject,\n\t\t\t\t\tsAction,\n\t\t\t\t\toSelectionVariant.toJSONString(),\n\t\t\t\t\tundefined,\n\t\t\t\t\tonError,\n\t\t\t\t\tundefined,\n\t\t\t\t\tsNavMode\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tthrow new Error(\"Semantic Object/action is not provided\");\n\t\t\t}\n\t\t};\n\t\tconst oBindingContext = this.base.getView().getBindingContext();\n\t\tconst oMetaModel = oBindingContext && (oBindingContext.getModel().getMetaModel() as ODataMetaModel);\n\t\tif (\n\t\t\t(this.getView().getViewData() as any).converterType === \"ObjectPage\" &&\n\t\t\toMetaModel &&\n\t\t\t!ModelHelper.isStickySessionSupported(oMetaModel)\n\t\t) {\n\t\t\tdraft.processDataLossOrDraftDiscardConfirmation(\n\t\t\t\t_doNavigate.bind(this),\n\t\t\t\tFunction.prototype,\n\t\t\t\tthis.base.getView().getBindingContext(),\n\t\t\t\tthis.base.getView().getController(),\n\t\t\t\ttrue,\n\t\t\t\tdraft.NavigationType.ForwardNavigation\n\t\t\t);\n\t\t} else {\n\t\t\t_doNavigate();\n\t\t}\n\t}\n\n\t/**\n\t * Prepare attributes to be passed to external navigation.\n\t *\n\t * @param oSemanticAttributes Context data after removing all sensitive information.\n\t * @param oContext Actual context from which the semanticAttributes were derived.\n\t * @returns Object of prepared attributes for external navigation and no conflict properties.\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tprepareContextForExternalNavigation(oSemanticAttributes: any, oContext: Context) {\n\t\t// 1. Find all distinct keys in the object SemanticAttributes\n\t\t// Store meta path for each occurence of the key\n\t\tconst oDistinctKeys: any = {},\n\t\t\tsContextPath = oContext.getPath(),\n\t\t\toMetaModel = oContext.getModel().getMetaModel() as ODataMetaModel,\n\t\t\tsMetaPath = oMetaModel.getMetaPath(sContextPath),\n\t\t\taMetaPathParts = sMetaPath.split(\"/\").filter(Boolean);\n\n\t\tfunction _findDistinctKeysInObject(LookUpObject: any, sLookUpObjectMetaPath: any) {\n\t\t\tfor (const sKey in LookUpObject) {\n\t\t\t\t// null case??\n\t\t\t\tif (LookUpObject[sKey] === null || typeof LookUpObject[sKey] !== \"object\") {\n\t\t\t\t\tif (!oDistinctKeys[sKey]) {\n\t\t\t\t\t\t// if key is found for the first time then create array\n\t\t\t\t\t\toDistinctKeys[sKey] = [];\n\t\t\t\t\t}\n\t\t\t\t\t// push path to array\n\t\t\t\t\toDistinctKeys[sKey].push(sLookUpObjectMetaPath);\n\t\t\t\t} else {\n\t\t\t\t\t// if a nested object is found\n\t\t\t\t\tconst oNewLookUpObject = LookUpObject[sKey];\n\t\t\t\t\t_findDistinctKeysInObject(oNewLookUpObject, `${sLookUpObjectMetaPath}/${sKey}`);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t_findDistinctKeysInObject(oSemanticAttributes, sMetaPath);\n\n\t\t// 2. Determine distinct key value and add conflicted paths to semantic attributes\n\t\tconst sMainEntitySetName = aMetaPathParts[0],\n\t\t\tsMainEntityTypeName = oMetaModel.getObject(`/${sMainEntitySetName}/@sapui.name`),\n\t\t\toPropertiesWithoutConflict: any = {};\n\t\tlet sMainEntityValuePath, sCurrentValuePath, sLastValuePath;\n\t\tfor (const sDistinctKey in oDistinctKeys) {\n\t\t\tconst aConflictingPaths = oDistinctKeys[sDistinctKey];\n\t\t\tlet sWinnerValuePath;\n\t\t\t// Find winner value for each distinct key in case of conflict by the following rule:\n\n\t\t\t// -> A. if any meta path for a distinct key is the same as main entity take that as the value\n\t\t\t// -> B. if A is not met keep the value from the current context (sMetaPath === path of distince key)\n\t\t\t// -> C. if A, B or C are not met take the last path for value\n\t\t\tif (aConflictingPaths.length > 1) {\n\t\t\t\t// conflict\n\t\t\t\tfor (let i = 0; i <= aConflictingPaths.length - 1; i++) {\n\t\t\t\t\tconst sPath = aConflictingPaths[i];\n\t\t\t\t\tlet sPathInContext = sPath.replace(sPath === sMetaPath ? sMetaPath : `${sMetaPath}/`, \"\");\n\t\t\t\t\tsPathInContext = (sPathInContext === \"\" ? sPathInContext : `${sPathInContext}/`) + sDistinctKey;\n\t\t\t\t\tconst sEntityTypeName = oMetaModel.getObject(`${sPath}/@sapui.name`);\n\t\t\t\t\t// rule A\n\n\t\t\t\t\t// rule A\n\t\t\t\t\tif (sEntityTypeName === sMainEntityTypeName) {\n\t\t\t\t\t\tsMainEntityValuePath = sPathInContext;\n\t\t\t\t\t}\n\n\t\t\t\t\t// rule B\n\t\t\t\t\tif (sPath === sMetaPath) {\n\t\t\t\t\t\tsCurrentValuePath = sPathInContext;\n\t\t\t\t\t}\n\n\t\t\t\t\t// rule C\n\t\t\t\t\tsLastValuePath = sPathInContext;\n\n\t\t\t\t\t// add conflicted path to semantic attributes\n\t\t\t\t\t// check if the current path points to main entity and prefix attribute names accordingly\n\t\t\t\t\toSemanticAttributes[\n\t\t\t\t\t\t`${sMetaPath}/${sPathInContext}`\n\t\t\t\t\t\t\t.split(\"/\")\n\t\t\t\t\t\t\t.filter(function (sValue: string) {\n\t\t\t\t\t\t\t\treturn sValue != \"\";\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.join(\".\")\n\t\t\t\t\t] = oContext.getProperty(sPathInContext);\n\t\t\t\t}\n\t\t\t\t// A || B || C\n\t\t\t\tsWinnerValuePath = sMainEntityValuePath || sCurrentValuePath || sLastValuePath;\n\t\t\t\toSemanticAttributes[sDistinctKey] = oContext.getProperty(sWinnerValuePath);\n\t\t\t\tsMainEntityValuePath = undefined;\n\t\t\t\tsCurrentValuePath = undefined;\n\t\t\t\tsLastValuePath = undefined;\n\t\t\t} else {\n\t\t\t\t// no conflict, add distinct key without adding paths\n\t\t\t\tconst sPath = aConflictingPaths[0]; // because there is only one and hence no conflict\n\t\t\t\tlet sPathInContext = sPath.replace(sPath === sMetaPath ? sMetaPath : `${sMetaPath}/`, \"\");\n\t\t\t\tsPathInContext = (sPathInContext === \"\" ? sPathInContext : `${sPathInContext}/`) + sDistinctKey;\n\t\t\t\toSemanticAttributes[sDistinctKey] = oContext.getProperty(sPathInContext);\n\t\t\t\toPropertiesWithoutConflict[sDistinctKey] = `${sMetaPath}/${sPathInContext}`\n\t\t\t\t\t.split(\"/\")\n\t\t\t\t\t.filter(function (sValue: string) {\n\t\t\t\t\t\treturn sValue != \"\";\n\t\t\t\t\t})\n\t\t\t\t\t.join(\".\");\n\t\t\t}\n\t\t}\n\t\t// 3. Remove all Navigation properties\n\t\tfor (const sProperty in oSemanticAttributes) {\n\t\t\tif (oSemanticAttributes[sProperty] !== null && typeof oSemanticAttributes[sProperty] === \"object\") {\n\t\t\t\tdelete oSemanticAttributes[sProperty];\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\tsemanticAttributes: oSemanticAttributes,\n\t\t\tpropertiesWithoutConflict: oPropertiesWithoutConflict\n\t\t};\n\t}\n\t/**\n\t * Prepare filter conditions to be passed to external navigation.\n\t *\n\t * @param oFilterBarConditions Filter conditions.\n\t * @param sRootPath Root path of the application.\n\t * @param aParameters Names of parameters to be considered.\n\t * @returns Object of prepared filter conditions for external navigation and no conflict filters.\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tprepareFiltersForExternalNavigation(oFilterBarConditions: any, sRootPath: string, aParameters?: any[]) {\n\t\tlet sPath;\n\t\tconst oDistinctKeys: any = {};\n\t\tconst oFilterConditionsWithoutConflict: any = {};\n\t\tlet sMainEntityValuePath, sCurrentValuePath, sFullContextPath, sWinnerValuePath, sPathInContext;\n\n\t\tfunction _findDistinctKeysInObject(LookUpObject: any) {\n\t\t\tlet sLookUpObjectMetaPath;\n\t\t\tfor (let sKey in LookUpObject) {\n\t\t\t\tif (LookUpObject[sKey]) {\n\t\t\t\t\tif (sKey.includes(\"/\")) {\n\t\t\t\t\t\tsLookUpObjectMetaPath = sKey; // \"/SalesOrdermanage/_Item/Material\"\n\t\t\t\t\t\tconst aPathParts = sKey.split(\"/\");\n\t\t\t\t\t\tsKey = aPathParts[aPathParts.length - 1];\n\t\t\t\t\t} else {\n\t\t\t\t\t\tsLookUpObjectMetaPath = sRootPath;\n\t\t\t\t\t}\n\t\t\t\t\tif (!oDistinctKeys[sKey]) {\n\t\t\t\t\t\t// if key is found for the first time then create array\n\t\t\t\t\t\toDistinctKeys[sKey] = [];\n\t\t\t\t\t}\n\n\t\t\t\t\t// push path to array\n\t\t\t\t\toDistinctKeys[sKey].push(sLookUpObjectMetaPath);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t_findDistinctKeysInObject(oFilterBarConditions);\n\t\tfor (const sDistinctKey in oDistinctKeys) {\n\t\t\tconst aConflictingPaths = oDistinctKeys[sDistinctKey];\n\n\t\t\tif (aConflictingPaths.length > 1) {\n\t\t\t\t// conflict\n\t\t\t\tfor (let i = 0; i <= aConflictingPaths.length - 1; i++) {\n\t\t\t\t\tsPath = aConflictingPaths[i];\n\t\t\t\t\tif (sPath === sRootPath) {\n\t\t\t\t\t\tsFullContextPath = `${sRootPath}/${sDistinctKey}`;\n\t\t\t\t\t\tsPathInContext = sDistinctKey;\n\t\t\t\t\t\tsMainEntityValuePath = sDistinctKey;\n\t\t\t\t\t\tif (aParameters && aParameters.includes(sDistinctKey)) {\n\t\t\t\t\t\t\toFilterBarConditions[`$Parameter.${sDistinctKey}`] = oFilterBarConditions[sDistinctKey];\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tsPathInContext = sPath;\n\t\t\t\t\t\tsFullContextPath = (`${sRootPath}/${sPath}` as any).replaceAll(/\\*/g, \"\");\n\t\t\t\t\t\tsCurrentValuePath = sPath;\n\t\t\t\t\t}\n\t\t\t\t\toFilterBarConditions[\n\t\t\t\t\t\tsFullContextPath\n\t\t\t\t\t\t\t.split(\"/\")\n\t\t\t\t\t\t\t.filter(function (sValue: any) {\n\t\t\t\t\t\t\t\treturn sValue != \"\";\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.join(\".\")\n\t\t\t\t\t] = oFilterBarConditions[sPathInContext];\n\t\t\t\t\tdelete oFilterBarConditions[sPath];\n\t\t\t\t}\n\n\t\t\t\tsWinnerValuePath = sMainEntityValuePath || sCurrentValuePath;\n\t\t\t\toFilterBarConditions[sDistinctKey] = oFilterBarConditions[sWinnerValuePath];\n\t\t\t} else {\n\t\t\t\t// no conflict, add distinct key without adding paths\n\t\t\t\tsPath = aConflictingPaths[0];\n\t\t\t\tsFullContextPath =\n\t\t\t\t\tsPath === sRootPath ? `${sRootPath}/${sDistinctKey}` : (`${sRootPath}/${sPath}` as any).replaceAll(\"*\", \"\");\n\t\t\t\toFilterConditionsWithoutConflict[sDistinctKey] = sFullContextPath\n\t\t\t\t\t.split(\"/\")\n\t\t\t\t\t.filter(function (sValue: any) {\n\t\t\t\t\t\treturn sValue != \"\";\n\t\t\t\t\t})\n\t\t\t\t\t.join(\".\");\n\t\t\t\tif (aParameters && aParameters.includes(sDistinctKey)) {\n\t\t\t\t\toFilterBarConditions[`$Parameter.${sDistinctKey}`] = oFilterBarConditions[sDistinctKey];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn {\n\t\t\tfilterConditions: oFilterBarConditions,\n\t\t\tfilterConditionsWithoutConflict: oFilterConditionsWithoutConflict\n\t\t};\n\t}\n\n\t/**\n\t * Get Navigation mode.\n\t *\n\t * @returns The navigation mode\n\t */\n\t@publicExtension()\n\t@extensible(OverrideExecution.Instead)\n\tgetNavigationMode() {\n\t\treturn undefined;\n\t}\n\t/**\n\t * Allows for navigation to a given intent (SemanticObject-Action) with the provided context, using a dialog that shows the contexts which cannot be passed\n\t * If semantic object mapping is provided, this setting is also applied to the selection variant after adaptation by a consumer.\n\t * This setting also removes any technical parameters and determines if an inplace or explace navigation should take place.\n\t *\n\t * @param sSemanticObject Semantic object for the target app\n\t * @param sAction  Action for the target app\n\t * @param [mNavigationParameters] Optional parameters to be passed to the external navigation\n\t * @param [mNavigationParameters.label]\n\t * @param [mNavigationParameters.navigationContexts] Single instance or multiple instances of {@link sap.ui.model.odata.v4.Context}, or alternatively an object or array of objects, to be passed to the intent.\n\t * @param [mNavigationParameters.applicableContexts] Single instance or multiple instances of {@link sap.ui.model.odata.v4.Context}, or alternatively an object or array of objects, to be passed to the intent and for which the IBN button is enabled\n\t * @param [mNavigationParameters.notApplicableContexts] Single instance or multiple instances of {@link sap.ui.model.odata.v4.Context}, or alternatively an object or array of objects, which cannot be passed to the intent.\n\t *\t\t  if an array of contexts is passed the context is used to determine the meta path and accordingly remove the sensitive data\n\t *\t\t  If an array of objects is passed, the following format is expected:\n\t *\t\t  {\n\t *\t\t\tdata: {\n\t *\t \t\t\tProductID: 7634,\n\t *\t\t\t\tName: \"Laptop\"\n\t *\t\t\t },\n\t *\t\t\t metaPath: \"/SalesOrderManage\"\n\t *        }\n\t *\t\tThe metaPath is used to remove any sensitive data.\n\t * @param [mNavigationParameters.semanticObjectMapping] String representation of SemanticObjectMapping or SemanticObjectMapping that applies to this navigation\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tnavigateWithConfirmationDialog(\n\t\tsSemanticObject: string,\n\t\tsAction: string,\n\t\tmNavigationParameters?: {\n\t\t\tnavigationContexts?: object | any[];\n\t\t\tapplicableContexts?: object | any[];\n\t\t\tnotApplicableContexts?: any;\n\t\t\tlabel?: string;\n\t\t\tsemanticObjectMapping?: string | object;\n\t\t}\n\t) {\n\t\tif (mNavigationParameters?.notApplicableContexts && mNavigationParameters.notApplicableContexts?.length >= 1) {\n\t\t\tlet oApplicableContextDialog: Dialog;\n\t\t\tconst oController = {\n\t\t\t\tonClose: function () {\n\t\t\t\t\t// User cancels action\n\t\t\t\t\toApplicableContextDialog.close();\n\t\t\t\t},\n\t\t\t\tonContinue: () => {\n\t\t\t\t\t// Users continues the action with the bound contexts\n\t\t\t\t\tmNavigationParameters.navigationContexts = mNavigationParameters.applicableContexts;\n\t\t\t\t\toApplicableContextDialog.close();\n\t\t\t\t\tthis.navigate(sSemanticObject, sAction, mNavigationParameters);\n\t\t\t\t}\n\t\t\t};\n\t\t\tconst fnOpenAndFillDialog = function () {\n\t\t\t\tlet oDialogContent;\n\t\t\t\tconst nNotApplicable = mNavigationParameters.notApplicableContexts.length,\n\t\t\t\t\taNotApplicableItems = [];\n\t\t\t\tfor (let i = 0; i < mNavigationParameters.notApplicableContexts.length; i++) {\n\t\t\t\t\toDialogContent = mNavigationParameters.notApplicableContexts[i].getObject();\n\t\t\t\t\taNotApplicableItems.push(oDialogContent);\n\t\t\t\t}\n\t\t\t\tconst oNotApplicableItemsModel = new JSONModel(aNotApplicableItems);\n\t\t\t\tconst oTotals = new JSONModel({ total: nNotApplicable, label: mNavigationParameters.label });\n\t\t\t\toApplicableContextDialog.setModel(oNotApplicableItemsModel, \"notApplicable\");\n\t\t\t\toApplicableContextDialog.setModel(oTotals, \"totals\");\n\t\t\t\toApplicableContextDialog.open();\n\t\t\t};\n\t\t\t// Show the contexts that are not applicable and will not therefore be processed\n\t\t\tconst sFragmentName = \"sap.fe.core.controls.ActionPartial\";\n\t\t\tconst oDialogFragment = XMLTemplateProcessor.loadTemplate(sFragmentName, \"fragment\");\n\t\t\tconst oModel = this._oView.getModel();\n\t\t\tconst oMetaModel = oModel.getMetaModel() as ODataMetaModel;\n\t\t\tconst sCanonicalPath = mNavigationParameters.notApplicableContexts[0].getCanonicalPath();\n\t\t\tconst sEntitySet = `${sCanonicalPath.substr(0, sCanonicalPath.indexOf(\"(\"))}/`;\n\t\t\tPromise.resolve(\n\t\t\t\tXMLPreprocessor.process(\n\t\t\t\t\toDialogFragment,\n\t\t\t\t\t{ name: sFragmentName },\n\t\t\t\t\t{\n\t\t\t\t\t\tbindingContexts: {\n\t\t\t\t\t\t\tentityType: oMetaModel.createBindingContext(sEntitySet)\n\t\t\t\t\t\t},\n\t\t\t\t\t\tmodels: {\n\t\t\t\t\t\t\tentityType: oMetaModel,\n\t\t\t\t\t\t\tmetaModel: oMetaModel\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t)\n\t\t\t)\n\t\t\t\t.then(function (oFragment: any) {\n\t\t\t\t\treturn Fragment.load({ definition: oFragment, controller: oController });\n\t\t\t\t})\n\t\t\t\t.then((oPopover: any) => {\n\t\t\t\t\toApplicableContextDialog = oPopover;\n\t\t\t\t\tthis.getView().addDependent(oPopover);\n\t\t\t\t\tfnOpenAndFillDialog();\n\t\t\t\t})\n\t\t\t\t.catch(function () {\n\t\t\t\t\tLog.error(\"Error\");\n\t\t\t\t});\n\t\t} else {\n\t\t\tthis.navigate(sSemanticObject, sAction, mNavigationParameters);\n\t\t}\n\t}\n\t_removeTechnicalParameters(oSelectionVariant: any) {\n\t\toSelectionVariant.removeSelectOption(\"@odata.context\");\n\t\toSelectionVariant.removeSelectOption(\"@odata.metadataEtag\");\n\t\toSelectionVariant.removeSelectOption(\"SAP__Messages\");\n\t}\n\t/**\n\t * Get targeted Entity set.\n\t *\n\t * @returns Entity set name\n\t */\n\t@privateExtension()\n\tgetEntitySet() {\n\t\treturn (this._oView.getViewData() as any).entitySet;\n\t}\n\t/**\n\t * Removes sensitive data from the semantic attribute with respect to the entitySet.\n\t *\n\t * @param oAttributes Context data\n\t * @param sMetaPath Meta path to reach the entitySet in the MetaModel\n\t * @returns Array of semantic Attributes\n\t * @private\n\t */\n\t// TO-DO add unit tests for this function in the controller extension qunit.\n\t@publicExtension()\n\t@finalExtension()\n\tremoveSensitiveData(oAttributes: any, sMetaPath: string) {\n\t\tif (oAttributes) {\n\t\t\tconst { transAggregations, customAggregates } = this._getAggregates(\n\t\t\t\tsMetaPath,\n\t\t\t\tthis.base.getView(),\n\t\t\t\tthis.base.getAppComponent().getDiagnostics()\n\t\t\t);\n\t\t\tconst aProperties = Object.keys(oAttributes);\n\t\t\tif (aProperties.length) {\n\t\t\t\tdelete oAttributes[\"@odata.context\"];\n\t\t\t\tdelete oAttributes[\"@odata.metadataEtag\"];\n\t\t\t\tdelete oAttributes[\"SAP__Messages\"];\n\t\t\t\tfor (let j = 0; j < aProperties.length; j++) {\n\t\t\t\t\tif (oAttributes[aProperties[j]] && typeof oAttributes[aProperties[j]] === \"object\") {\n\t\t\t\t\t\tthis.removeSensitiveData(oAttributes[aProperties[j]], `${sMetaPath}/${aProperties[j]}`);\n\t\t\t\t\t}\n\t\t\t\t\tconst sProp = aProperties[j];\n\t\t\t\t\tif (sProp.indexOf(\"@odata.type\") > -1) {\n\t\t\t\t\t\tdelete oAttributes[aProperties[j]];\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tthis._deleteAggregates([...transAggregations, ...customAggregates], aProperties[j], oAttributes);\n\t\t\t\t\tconst aPropertyAnnotations = this._getPropertyAnnotations(sProp, sMetaPath, oAttributes, this._oMetaModel);\n\t\t\t\t\tif (aPropertyAnnotations) {\n\t\t\t\t\t\tif (\n\t\t\t\t\t\t\taPropertyAnnotations[\"com.sap.vocabularies.PersonalData.v1.IsPotentiallySensitive\"] ||\n\t\t\t\t\t\t\taPropertyAnnotations[\"com.sap.vocabularies.UI.v1.ExcludeFromNavigationContext\"] ||\n\t\t\t\t\t\t\taPropertyAnnotations[\"com.sap.vocabularies.Analytics.v1.Measure\"]\n\t\t\t\t\t\t) {\n\t\t\t\t\t\t\tdelete oAttributes[sProp];\n\t\t\t\t\t\t} else if (aPropertyAnnotations[\"com.sap.vocabularies.Common.v1.FieldControl\"]) {\n\t\t\t\t\t\t\tconst oFieldControl = aPropertyAnnotations[\"com.sap.vocabularies.Common.v1.FieldControl\"];\n\t\t\t\t\t\t\tif (oFieldControl[\"$EnumMember\"] && oFieldControl[\"$EnumMember\"].split(\"/\")[1] === \"Inapplicable\") {\n\t\t\t\t\t\t\t\tdelete oAttributes[sProp];\n\t\t\t\t\t\t\t} else if (\n\t\t\t\t\t\t\t\toFieldControl[\"$Path\"] &&\n\t\t\t\t\t\t\t\tthis._isFieldControlPathInapplicable(oFieldControl[\"$Path\"], oAttributes)\n\t\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t\tdelete oAttributes[sProp];\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}\n\t\t}\n\t\treturn oAttributes;\n\t}\n\n\t/**\n\t * Remove the attribute from navigation data if it is a measure.\n\t *\n\t * @param aggregates Array of Aggregates\n\t * @param sProp Attribute name\n\t * @param oAttributes SemanticAttributes\n\t */\n\t_deleteAggregates(aggregates: string[] | undefined, sProp: string, oAttributes: any) {\n\t\tif (aggregates && aggregates.indexOf(sProp) > -1) {\n\t\t\tdelete oAttributes[sProp];\n\t\t}\n\t}\n\n\t/**\n\t * Returns the property annotations.\n\t *\n\t * @param sProp\n\t * @param sMetaPath\n\t * @param oAttributes\n\t * @param oMetaModel\n\t * @returns - The property annotations\n\t */\n\t_getPropertyAnnotations(sProp: string, sMetaPath: string, oAttributes: any, oMetaModel: ODataMetaModel) {\n\t\tif (oAttributes[sProp] && sMetaPath && !sMetaPath.includes(\"undefined\")) {\n\t\t\tconst oContext = oMetaModel.createBindingContext(`${sMetaPath}/${sProp}`) as ODataV4Context;\n\t\t\tconst oFullContext = MetaModelConverter.getInvolvedDataModelObjects(oContext);\n\t\t\treturn oFullContext?.targetObject?.annotations?._annotations;\n\t\t}\n\t\treturn null;\n\t}\n\n\t/**\n\t * Returns the aggregates part of the EntitySet or EntityType.\n\t *\n\t * @param sMetaPath\n\t * @param oView\n\t * @param oDiagnostics\n\t * @returns - The aggregates\n\t */\n\t_getAggregates(sMetaPath: string, oView: View, oDiagnostics: Diagnostics) {\n\t\tconst converterContext = this._getConverterContext(sMetaPath, oView, oDiagnostics);\n\t\tconst aggregationHelper = new AggregationHelper(converterContext.getEntityType(), converterContext);\n\t\tconst isAnalyticsSupported = aggregationHelper.isAnalyticsSupported();\n\t\tlet transAggregations = [],\n\t\t\tcustomAggregates = [];\n\t\tif (isAnalyticsSupported) {\n\t\t\ttransAggregations = aggregationHelper.getTransAggregations();\n\t\t\tif (transAggregations.length) {\n\t\t\t\ttransAggregations = transAggregations.map((transAgg: any) => {\n\t\t\t\t\treturn transAgg.Name || transAgg.Value;\n\t\t\t\t});\n\t\t\t}\n\t\t\tcustomAggregates = aggregationHelper.getCustomAggregateDefinitions();\n\t\t\tif (customAggregates.length) {\n\t\t\t\tcustomAggregates = customAggregates.map((customAggregate: any) => {\n\t\t\t\t\treturn customAggregate.qualifier;\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn { transAggregations, customAggregates };\n\t}\n\n\t/**\n\t * Returns converterContext.\n\t *\n\t * @param sMetaPath\n\t * @param oView\n\t * @param oDiagnostics\n\t * @returns - ConverterContext\n\t */\n\t_getConverterContext(sMetaPath: string, oView: View, oDiagnostics: Diagnostics) {\n\t\tconst oViewData: any = oView.getViewData();\n\t\tlet sEntitySet = oViewData.entitySet;\n\t\tconst sContextPath = oViewData.contextPath;\n\t\tif (sContextPath && (!sEntitySet || sEntitySet.includes(\"/\"))) {\n\t\t\tsEntitySet = oViewData?.fullContextPath.split(\"/\")[1];\n\t\t}\n\t\treturn CommonUtils.getConverterContextForPath(\n\t\t\tsMetaPath,\n\t\t\toView.getModel().getMetaModel() as ODataMetaModel,\n\t\t\tsEntitySet,\n\t\t\toDiagnostics\n\t\t);\n\t}\n\n\t/**\n\t * Check if path-based FieldControl evaluates to inapplicable.\n\t *\n\t * @param sFieldControlPath Field control path\n\t * @param oAttribute SemanticAttributes\n\t * @returns `true` if inapplicable\n\t */\n\t_isFieldControlPathInapplicable(sFieldControlPath: string, oAttribute: any) {\n\t\tlet bInapplicable = false;\n\t\tconst aParts = sFieldControlPath.split(\"/\");\n\t\t// sensitive data is removed only if the path has already been resolved.\n\t\tif (aParts.length > 1) {\n\t\t\tbInapplicable =\n\t\t\t\toAttribute[aParts[0]] && oAttribute[aParts[0]].hasOwnProperty(aParts[1]) && oAttribute[aParts[0]][aParts[1]] === 0;\n\t\t} else {\n\t\t\tbInapplicable = oAttribute[sFieldControlPath] === 0;\n\t\t}\n\t\treturn bInapplicable;\n\t}\n\t/**\n\t * Method to replace Local Properties with Semantic Object mappings.\n\t *\n\t * @param oSelectionVariant SelectionVariant consisting of filterbar, Table and Page Context\n\t * @param vMappings A string representation of semantic object mapping\n\t * @returns - Modified SelectionVariant with LocalProperty replaced with SemanticObjectProperties.\n\t */\n\t_applySemanticObjectMappings(oSelectionVariant: SelectionVariant, vMappings: object | string) {\n\t\tconst oMappings = typeof vMappings === \"string\" ? JSON.parse(vMappings) : vMappings;\n\t\tfor (let i = 0; i < oMappings.length; i++) {\n\t\t\tconst sLocalProperty =\n\t\t\t\t(oMappings[i][\"LocalProperty\"] && oMappings[i][\"LocalProperty\"][\"$PropertyPath\"]) ||\n\t\t\t\t(oMappings[i][\"@com.sap.vocabularies.Common.v1.LocalProperty\"] &&\n\t\t\t\t\toMappings[i][\"@com.sap.vocabularies.Common.v1.LocalProperty\"][\"$Path\"]);\n\t\t\tconst sSemanticObjectProperty =\n\t\t\t\toMappings[i][\"SemanticObjectProperty\"] || oMappings[i][\"@com.sap.vocabularies.Common.v1.SemanticObjectProperty\"];\n\t\t\tconst oSelectOption = oSelectionVariant.getSelectOption(sLocalProperty);\n\t\t\tif (oSelectOption) {\n\t\t\t\t//Create a new SelectOption with sSemanticObjectProperty as the property Name and remove the older one\n\t\t\t\toSelectionVariant.removeSelectOption(sLocalProperty);\n\t\t\t\toSelectionVariant.massAddSelectOption(sSemanticObjectProperty, oSelectOption);\n\t\t\t}\n\t\t}\n\t\treturn oSelectionVariant;\n\t}\n\t/**\n\t * Navigates to an Outbound provided in the manifest.\n\t *\n\t * @function\n\t * @param sOutbound Identifier to location the outbound in the manifest\n\t * @param mNavigationParameters Optional map containing key/value pairs to be passed to the intent\n\t * @alias sap.fe.core.controllerextensions.IntentBasedNavigation#navigateOutbound\n\t * @since 1.86.0\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tnavigateOutbound(sOutbound: string, mNavigationParameters: any) {\n\t\tlet aNavParams: any[] | undefined;\n\t\tconst oManifestEntry = this.base.getAppComponent().getManifestEntry(\"sap.app\"),\n\t\t\toOutbound = oManifestEntry.crossNavigation?.outbounds?.[sOutbound];\n\t\tif (!oOutbound) {\n\t\t\tLog.error(\"Outbound is not defined in manifest!!\");\n\t\t\treturn;\n\t\t}\n\t\tconst sSemanticObject = oOutbound.semanticObject,\n\t\t\tsAction = oOutbound.action,\n\t\t\toutboundParams = oOutbound.parameters && this.getOutboundParams(oOutbound.parameters);\n\n\t\tif (mNavigationParameters) {\n\t\t\taNavParams = [];\n\t\t\tObject.keys(mNavigationParameters).forEach(function (key: string) {\n\t\t\t\tlet oParams: any;\n\t\t\t\tif (Array.isArray(mNavigationParameters[key])) {\n\t\t\t\t\tconst aValues = mNavigationParameters[key];\n\t\t\t\t\tfor (let i = 0; i < aValues.length; i++) {\n\t\t\t\t\t\toParams = {};\n\t\t\t\t\t\toParams[key] = aValues[i];\n\t\t\t\t\t\taNavParams?.push(oParams);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\toParams = {};\n\t\t\t\t\toParams[key] = mNavigationParameters[key];\n\t\t\t\t\taNavParams?.push(oParams);\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\tif (aNavParams || outboundParams) {\n\t\t\tmNavigationParameters = {\n\t\t\t\tnavigationContexts: {\n\t\t\t\t\tdata: aNavParams || outboundParams\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t\tthis.base._intentBasedNavigation.navigate(sSemanticObject, sAction, mNavigationParameters);\n\t}\n\n\t/**\n\t * Method to apply outbound parameters defined in the manifest.\n\t *\n\t * @param oSelectionVariant SelectionVariant consisting of a filter bar, a table, and a page context\n\t * @param vOutboundParams Outbound Properties defined in the manifest\n\t * @returns - The modified SelectionVariant with outbound parameters.\n\t */\n\t_applyOutboundParams(oSelectionVariant: SelectionVariant, vOutboundParams: any) {\n\t\tconst aParameters = Object.keys(vOutboundParams);\n\t\tconst aSelectProperties = oSelectionVariant.getSelectOptionsPropertyNames();\n\t\taParameters.forEach(function (key: string) {\n\t\t\tif (!aSelectProperties.includes(key)) {\n\t\t\t\toSelectionVariant.addSelectOption(key, \"I\", \"EQ\", vOutboundParams[key]);\n\t\t\t}\n\t\t});\n\t\treturn oSelectionVariant;\n\t}\n\t/**\n\t * Method to get the outbound parameters defined in the manifest.\n\t *\n\t * @function\n\t * @param oOutboundParams Parameters defined in the outbounds. Only \"plain\" is supported\n\t * @returns Parameters with the key-Value pair\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tgetOutboundParams(oOutboundParams: any) {\n\t\tconst oParamsMapping: any = {};\n\t\tif (oOutboundParams) {\n\t\t\tconst aParameters = Object.keys(oOutboundParams) || [];\n\t\t\tif (aParameters.length > 0) {\n\t\t\t\taParameters.forEach(function (key: string) {\n\t\t\t\t\tconst oMapping = oOutboundParams[key];\n\t\t\t\t\tif (oMapping.value && oMapping.value.value && oMapping.value.format === \"plain\") {\n\t\t\t\t\t\tif (!oParamsMapping[key]) {\n\t\t\t\t\t\t\toParamsMapping[key] = oMapping.value.value;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn oParamsMapping;\n\t}\n\n\t/**\n\t * Triggers an outbound navigation when a user chooses the chevron.\n\t *\n\t * @param {object} oController\n\t * @param {string} sOutboundTarget Name of the outbound target (needs to be defined in the manifest)\n\t * @param {sap.ui.model.odata.v4.Context} oContext The context that contains the data for the target app\n\t * @param {string} sCreatePath Create path when the chevron is created.\n\t * @returns {Promise} Promise which is resolved once the navigation is triggered\n\t */\n\n\t@publicExtension()\n\t@finalExtension()\n\tonChevronPressNavigateOutBound(oController: PageController, sOutboundTarget: string, oContext: any, sCreatePath: string) {\n\t\tconst oOutbounds = (oController.getAppComponent() as any).getRoutingService().getOutbounds();\n\t\tconst oDisplayOutbound = oOutbounds[sOutboundTarget];\n\t\tlet additionalNavigationParameters;\n\t\tif (oDisplayOutbound && oDisplayOutbound.semanticObject && oDisplayOutbound.action) {\n\t\t\tconst oRefreshStrategies: any = {\n\t\t\t\tintents: {}\n\t\t\t};\n\t\t\tconst oDefaultRefreshStrategy: any = {};\n\t\t\tlet sMetaPath;\n\n\t\t\tif (oContext) {\n\t\t\t\tif (oContext.isA && oContext.isA(\"sap.ui.model.odata.v4.Context\")) {\n\t\t\t\t\tsMetaPath = ModelHelper.getMetaPathForContext(oContext);\n\t\t\t\t\toContext = [oContext];\n\t\t\t\t} else {\n\t\t\t\t\tsMetaPath = ModelHelper.getMetaPathForContext(oContext[0]);\n\t\t\t\t}\n\t\t\t\toDefaultRefreshStrategy[sMetaPath] = \"self\";\n\t\t\t\toRefreshStrategies[\"_feDefault\"] = oDefaultRefreshStrategy;\n\t\t\t}\n\n\t\t\tif (sCreatePath) {\n\t\t\t\tconst sKey = `${oDisplayOutbound.semanticObject}-${oDisplayOutbound.action}`;\n\t\t\t\toRefreshStrategies.intents[sKey] = {};\n\t\t\t\toRefreshStrategies.intents[sKey][sCreatePath] = \"self\";\n\t\t\t}\n\t\t\tif (oDisplayOutbound && oDisplayOutbound.parameters) {\n\t\t\t\tconst oParams = oDisplayOutbound.parameters && this.getOutboundParams(oDisplayOutbound.parameters);\n\t\t\t\tif (Object.keys(oParams).length > 0) {\n\t\t\t\t\tadditionalNavigationParameters = oParams;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\toController._intentBasedNavigation.navigate(oDisplayOutbound.semanticObject, oDisplayOutbound.action, {\n\t\t\t\tnavigationContexts: oContext,\n\t\t\t\trefreshStrategies: oRefreshStrategies,\n\t\t\t\tadditionalNavigationParameters: additionalNavigationParameters\n\t\t\t});\n\n\t\t\t//TODO: check why returning a promise is required\n\t\t\treturn Promise.resolve();\n\t\t} else {\n\t\t\tthrow new Error(`outbound target ${sOutboundTarget} not found in cross navigation definition of manifest`);\n\t\t}\n\t}\n}\n\nexport default InternalIntentBasedNavigation;\n"],"mappings":";AAAA;AAAA;AAAA;;;;;;;;;;;;;;;EAkCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EAPA,IASMA,6BAA6B,WADlCC,cAAc,CAAC,kEAAkE,CAAC,UAOjFC,cAAc,EAAE,UAkChBC,eAAe,EAAE,UACjBC,cAAc,EAAE,UA+JhBD,eAAe,EAAE,UACjBC,cAAc,EAAE,UAmHhBD,eAAe,EAAE,UACjBC,cAAc,EAAE,UA0FhBD,eAAe,EAAE,WACjBE,UAAU,CAACC,iBAAiB,CAACC,OAAO,CAAC,WA4BrCJ,eAAe,EAAE,WACjBC,cAAc,EAAE,WAuFhBI,gBAAgB,EAAE,WAalBL,eAAe,EAAE,WACjBC,cAAc,EAAE,WA2LhBD,eAAe,EAAE,WACjBC,cAAc,EAAE,WAiEhBD,eAAe,EAAE,WACjBC,cAAc,EAAE,WA6BhBD,eAAe,EAAE,WACjBC,cAAc,EAAE;IAAA;IAAA;MAAA;IAAA;IAAA;IAAA,OA/yBjBK,MAAM,GADN,kBACS;MACR,IAAI,CAACC,cAAc,GAAG,IAAI,CAACC,IAAI,CAACC,eAAe,EAAE;MACjD,IAAI,CAACC,WAAW,GAAG,IAAI,CAACH,cAAc,CAACI,QAAQ,EAAE,CAACC,YAAY,EAAoB;MAClF,IAAI,CAACC,mBAAmB,GAAG,IAAI,CAACN,cAAc,CAACO,oBAAoB,EAAE;MACrE,IAAI,CAACC,MAAM,GAAG,IAAI,CAACP,IAAI,CAACQ,OAAO,EAAE;IAClC;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAzBC;IAAA,OA4BAC,QAAQ,GAFR,kBAGCC,eAAuB,EACvBC,OAAe,EACfC,qBAQY,EACX;MACD,MAAMC,WAAW,GAAIC,QAAc,IAAK;QACvC,MAAMC,mBAAmB,GAAGH,qBAAqB,IAAIA,qBAAqB,CAACI,kBAAkB;UAC5FC,mBAAmB,GAClBF,mBAAmB,IAAI,CAACG,KAAK,CAACC,OAAO,CAACJ,mBAAmB,CAAC,GAAG,CAACA,mBAAmB,CAAC,GAAGA,mBAAmB;UACzGK,sBAAsB,GAAGR,qBAAqB,IAAIA,qBAAqB,CAACS,qBAAqB;UAC7FC,eAAe,GAAGV,qBAAqB,IAAIA,qBAAqB,CAACW,8BAA8B;UAC/FC,WAAgB,GAAG;YAClBC,cAAc,EAAEf,eAAe;YAC/BgB,MAAM,EAAEf;UACT,CAAC;UACDgB,KAAK,GAAG,IAAI,CAAC3B,IAAI,CAACQ,OAAO,EAAE;UAC3BoB,WAAW,GAAGD,KAAK,CAACE,aAAa,EAAoB;QAEtD,IAAIf,QAAQ,EAAE;UACb,IAAI,CAACP,MAAM,CAACuB,iBAAiB,CAAChB,QAAQ,CAAC;QACxC;QAEA,IAAIJ,eAAe,IAAIC,OAAO,EAAE;UAC/B,IAAIoB,mBAA0B,GAAG,EAAE;YAClCC,iBAAsB,GAAG,IAAIC,gBAAgB,EAAE;UAChD;UACA,IAAIhB,mBAAmB,IAAIA,mBAAmB,CAACiB,MAAM,EAAE;YACtDjB,mBAAmB,CAACkB,OAAO,CAAEC,kBAAuB,IAAK;cACxD;cACA;cACA,IAAIA,kBAAkB,CAACC,GAAG,IAAID,kBAAkB,CAACC,GAAG,CAAC,+BAA+B,CAAC,EAAE;gBACtF;gBACA,IAAIC,mBAAmB,GAAGF,kBAAkB,CAACG,SAAS,EAAE;gBACxD,MAAMC,SAAS,GAAG,IAAI,CAACtC,WAAW,CAACuC,WAAW,CAACL,kBAAkB,CAACM,OAAO,EAAE,CAAC;gBAC5E;gBACAJ,mBAAmB,GAAG,IAAI,CAACK,mBAAmB,CAACL,mBAAmB,EAAEE,SAAS,CAAC;gBAC9E,MAAMI,WAAW,GAAG,IAAI,CAACC,mCAAmC,CAACP,mBAAmB,EAAEF,kBAAkB,CAAC;gBACrGZ,WAAW,CAAC,2BAA2B,CAAC,GAAGoB,WAAW,CAACE,yBAAyB;gBAChFf,mBAAmB,CAACgB,IAAI,CAACH,WAAW,CAACI,kBAAkB,CAAC;cACzD,CAAC,MAAM,IACN,EAAEZ,kBAAkB,IAAIlB,KAAK,CAACC,OAAO,CAACiB,kBAAkB,CAACa,IAAI,CAAC,CAAC,IAC/D,OAAOb,kBAAkB,KAAK,QAAQ,EACrC;gBACD;gBACAL,mBAAmB,CAACgB,IAAI,CAAC,IAAI,CAACJ,mBAAmB,CAACP,kBAAkB,CAACa,IAAI,EAAEb,kBAAkB,CAACc,QAAQ,CAAC,CAAC;cACzG,CAAC,MAAM,IAAId,kBAAkB,IAAIlB,KAAK,CAACC,OAAO,CAACiB,kBAAkB,CAACa,IAAI,CAAC,EAAE;gBACxE;gBACA;gBACAlB,mBAAmB,GAAG,IAAI,CAACY,mBAAmB,CAACP,kBAAkB,CAACa,IAAI,EAAEb,kBAAkB,CAACc,QAAQ,CAAC;cACrG;YACD,CAAC,CAAC;UACH;UACA;UACA,IAAInB,mBAAmB,IAAIA,mBAAmB,CAACG,MAAM,EAAE;YACtDF,iBAAiB,GAAG,IAAI,CAAC3B,mBAAmB,CAAC8C,gCAAgC,CAC5EpB,mBAAmB,EACnBC,iBAAiB,CAACoB,YAAY,EAAE,CAChC;UACF;;UAEA;UACA,MAAMC,MAAM,GAAG,IAAI,CAAC9C,MAAM,CAACJ,QAAQ,EAAE;YACpCmD,UAAU,GAAG,IAAI,CAACC,YAAY,EAAE;YAChCC,WAAW,GAAGF,UAAU,GAAG,IAAI,CAACjD,mBAAmB,CAACoD,mBAAmB,CAACH,UAAU,EAAED,MAAM,CAAC,GAAGK,SAAS;UACxG,IAAIF,WAAW,EAAE;YAChBxB,iBAAiB,CAAC2B,mBAAmB,CAACH,WAAW,CAAC;UACnD;;UAEA;UACA,IAAIlC,eAAe,EAAE;YACpB,IAAI,CAACsC,oBAAoB,CAAC5B,iBAAiB,EAAEV,eAAe,CAAC;UAC9D;;UAEA;UACAM,WAAW,CAACiC,qBAAqB,CAACC,sBAAsB,CAAC9B,iBAAiB,EAAER,WAAW,CAAC;;UAExF;UACA,IAAIJ,sBAAsB,EAAE;YAC3B,IAAI,CAAC2C,4BAA4B,CAAC/B,iBAAiB,EAAEZ,sBAAsB,CAAC;UAC7E;;UAEA;UACA,IAAI,CAAC4C,0BAA0B,CAAChC,iBAAiB,CAAC;;UAElD;UACA,MAAMiC,QAAQ,GAAGrC,WAAW,CAACsC,sBAAsB,CAACC,iBAAiB,EAAE;;UAEvE;UACA,MAAMC,kBAAkB,GAAIxD,qBAAqB,IAAIA,qBAAqB,CAACyD,iBAAiB,IAAK,CAAC,CAAC;YAClGC,cAAc,GAAG3C,KAAK,CAACxB,QAAQ,CAAC,UAAU,CAAc;UACzD,IAAImE,cAAc,EAAE;YACnB,IAAI,CAAC3C,KAAK,IAAKA,KAAK,CAAC4C,WAAW,EAAU,EAAEC,2BAA2B,EAAE;cACxE,MAAMC,sBAAsB,GAAI9C,KAAK,CAAC4C,WAAW,EAAE,CAASC,2BAA2B,IAAI,CAAC,CAAC;cAC7FE,YAAY,CAACN,kBAAkB,EAAEK,sBAAsB,CAAC;YACzD;YACA,MAAME,gBAAgB,GAAGC,eAAe,CAACC,2BAA2B,CAACT,kBAAkB,EAAE1D,eAAe,EAAEC,OAAO,CAAC;YAClH,IAAIgE,gBAAgB,EAAE;cACrBL,cAAc,CAACQ,WAAW,CAAC,8BAA8B,EAAEH,gBAAgB,CAAC;YAC7E;UACD;;UAEA;UACA,MAAMI,OAAO,GAAG,YAAY;YAC3BC,GAAG,CAACC,EAAE,CAACC,OAAO,CAAC,CAAC,kBAAkB,CAAC,EAAE,UAAUC,UAAe,EAAE;cAC/D,MAAMC,eAAe,GAAGC,IAAI,CAACC,wBAAwB,CAAC,aAAa,CAAC;cACpEH,UAAU,CAACI,KAAK,CAACH,eAAe,CAACI,OAAO,CAAC,0CAA0C,CAAC,EAAE;gBACrFC,KAAK,EAAEL,eAAe,CAACI,OAAO,CAAC,sBAAsB;cACtD,CAAC,CAAC;YACH,CAAC,CAAC;UACH,CAAC;UACD,IAAI,CAACnF,mBAAmB,CAACI,QAAQ,CAChCC,eAAe,EACfC,OAAO,EACPqB,iBAAiB,CAACoB,YAAY,EAAE,EAChCM,SAAS,EACTqB,OAAO,EACPrB,SAAS,EACTO,QAAQ,CACR;QACF,CAAC,MAAM;UACN,MAAM,IAAIyB,KAAK,CAAC,wCAAwC,CAAC;QAC1D;MACD,CAAC;MACD,MAAMC,eAAe,GAAG,IAAI,CAAC3F,IAAI,CAACQ,OAAO,EAAE,CAACoF,iBAAiB,EAAE;MAC/D,MAAMC,UAAU,GAAGF,eAAe,IAAKA,eAAe,CAACxF,QAAQ,EAAE,CAACC,YAAY,EAAqB;MACnG,IACE,IAAI,CAACI,OAAO,EAAE,CAAC+D,WAAW,EAAE,CAASuB,aAAa,KAAK,YAAY,IACpED,UAAU,IACV,CAACE,WAAW,CAACC,wBAAwB,CAACH,UAAU,CAAC,EAChD;QACDI,KAAK,CAACC,yCAAyC,CAC9CrF,WAAW,CAACsF,IAAI,CAAC,IAAI,CAAC,EACtBC,QAAQ,CAACC,SAAS,EAClB,IAAI,CAACrG,IAAI,CAACQ,OAAO,EAAE,CAACoF,iBAAiB,EAAE,EACvC,IAAI,CAAC5F,IAAI,CAACQ,OAAO,EAAE,CAACqB,aAAa,EAAE,EACnC,IAAI,EACJoE,KAAK,CAACK,cAAc,CAACC,iBAAiB,CACtC;MACF,CAAC,MAAM;QACN1F,WAAW,EAAE;MACd;IACD;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA,OANC;IAAA,OASAgC,mCAAmC,GAFnC,6CAEoCP,mBAAwB,EAAExB,QAAiB,EAAE;MAChF;MACA;MACA,MAAM0F,aAAkB,GAAG,CAAC,CAAC;QAC5BC,YAAY,GAAG3F,QAAQ,CAAC4B,OAAO,EAAE;QACjCmD,UAAU,GAAG/E,QAAQ,CAACX,QAAQ,EAAE,CAACC,YAAY,EAAoB;QACjEoC,SAAS,GAAGqD,UAAU,CAACpD,WAAW,CAACgE,YAAY,CAAC;QAChDC,cAAc,GAAGlE,SAAS,CAACmE,KAAK,CAAC,GAAG,CAAC,CAACC,MAAM,CAACC,OAAO,CAAC;MAEtD,SAASC,yBAAyB,CAACC,YAAiB,EAAEC,qBAA0B,EAAE;QACjF,KAAK,MAAMC,IAAI,IAAIF,YAAY,EAAE;UAChC;UACA,IAAIA,YAAY,CAACE,IAAI,CAAC,KAAK,IAAI,IAAI,OAAOF,YAAY,CAACE,IAAI,CAAC,KAAK,QAAQ,EAAE;YAC1E,IAAI,CAACT,aAAa,CAACS,IAAI,CAAC,EAAE;cACzB;cACAT,aAAa,CAACS,IAAI,CAAC,GAAG,EAAE;YACzB;YACA;YACAT,aAAa,CAACS,IAAI,CAAC,CAAClE,IAAI,CAACiE,qBAAqB,CAAC;UAChD,CAAC,MAAM;YACN;YACA,MAAME,gBAAgB,GAAGH,YAAY,CAACE,IAAI,CAAC;YAC3CH,yBAAyB,CAACI,gBAAgB,EAAG,GAAEF,qBAAsB,IAAGC,IAAK,EAAC,CAAC;UAChF;QACD;MACD;MAEAH,yBAAyB,CAACxE,mBAAmB,EAAEE,SAAS,CAAC;;MAEzD;MACA,MAAM2E,kBAAkB,GAAGT,cAAc,CAAC,CAAC,CAAC;QAC3CU,mBAAmB,GAAGvB,UAAU,CAACtD,SAAS,CAAE,IAAG4E,kBAAmB,cAAa,CAAC;QAChFE,0BAA+B,GAAG,CAAC,CAAC;MACrC,IAAIC,oBAAoB,EAAEC,iBAAiB,EAAEC,cAAc;MAC3D,KAAK,MAAMC,YAAY,IAAIjB,aAAa,EAAE;QACzC,MAAMkB,iBAAiB,GAAGlB,aAAa,CAACiB,YAAY,CAAC;QACrD,IAAIE,gBAAgB;QACpB;;QAEA;QACA;QACA;QACA,IAAID,iBAAiB,CAACxF,MAAM,GAAG,CAAC,EAAE;UACjC;UACA,KAAK,IAAI0F,CAAC,GAAG,CAAC,EAAEA,CAAC,IAAIF,iBAAiB,CAACxF,MAAM,GAAG,CAAC,EAAE0F,CAAC,EAAE,EAAE;YACvD,MAAMC,KAAK,GAAGH,iBAAiB,CAACE,CAAC,CAAC;YAClC,IAAIE,cAAc,GAAGD,KAAK,CAACE,OAAO,CAACF,KAAK,KAAKrF,SAAS,GAAGA,SAAS,GAAI,GAAEA,SAAU,GAAE,EAAE,EAAE,CAAC;YACzFsF,cAAc,GAAG,CAACA,cAAc,KAAK,EAAE,GAAGA,cAAc,GAAI,GAAEA,cAAe,GAAE,IAAIL,YAAY;YAC/F,MAAMO,eAAe,GAAGnC,UAAU,CAACtD,SAAS,CAAE,GAAEsF,KAAM,cAAa,CAAC;YACpE;;YAEA;YACA,IAAIG,eAAe,KAAKZ,mBAAmB,EAAE;cAC5CE,oBAAoB,GAAGQ,cAAc;YACtC;;YAEA;YACA,IAAID,KAAK,KAAKrF,SAAS,EAAE;cACxB+E,iBAAiB,GAAGO,cAAc;YACnC;;YAEA;YACAN,cAAc,GAAGM,cAAc;;YAE/B;YACA;YACAxF,mBAAmB,CACjB,GAAEE,SAAU,IAAGsF,cAAe,EAAC,CAC9BnB,KAAK,CAAC,GAAG,CAAC,CACVC,MAAM,CAAC,UAAUqB,MAAc,EAAE;cACjC,OAAOA,MAAM,IAAI,EAAE;YACpB,CAAC,CAAC,CACDC,IAAI,CAAC,GAAG,CAAC,CACX,GAAGpH,QAAQ,CAACqH,WAAW,CAACL,cAAc,CAAC;UACzC;UACA;UACAH,gBAAgB,GAAGL,oBAAoB,IAAIC,iBAAiB,IAAIC,cAAc;UAC9ElF,mBAAmB,CAACmF,YAAY,CAAC,GAAG3G,QAAQ,CAACqH,WAAW,CAACR,gBAAgB,CAAC;UAC1EL,oBAAoB,GAAG5D,SAAS;UAChC6D,iBAAiB,GAAG7D,SAAS;UAC7B8D,cAAc,GAAG9D,SAAS;QAC3B,CAAC,MAAM;UACN;UACA,MAAMmE,KAAK,GAAGH,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;UACpC,IAAII,cAAc,GAAGD,KAAK,CAACE,OAAO,CAACF,KAAK,KAAKrF,SAAS,GAAGA,SAAS,GAAI,GAAEA,SAAU,GAAE,EAAE,EAAE,CAAC;UACzFsF,cAAc,GAAG,CAACA,cAAc,KAAK,EAAE,GAAGA,cAAc,GAAI,GAAEA,cAAe,GAAE,IAAIL,YAAY;UAC/FnF,mBAAmB,CAACmF,YAAY,CAAC,GAAG3G,QAAQ,CAACqH,WAAW,CAACL,cAAc,CAAC;UACxET,0BAA0B,CAACI,YAAY,CAAC,GAAI,GAAEjF,SAAU,IAAGsF,cAAe,EAAC,CACzEnB,KAAK,CAAC,GAAG,CAAC,CACVC,MAAM,CAAC,UAAUqB,MAAc,EAAE;YACjC,OAAOA,MAAM,IAAI,EAAE;UACpB,CAAC,CAAC,CACDC,IAAI,CAAC,GAAG,CAAC;QACZ;MACD;MACA;MACA,KAAK,MAAME,SAAS,IAAI9F,mBAAmB,EAAE;QAC5C,IAAIA,mBAAmB,CAAC8F,SAAS,CAAC,KAAK,IAAI,IAAI,OAAO9F,mBAAmB,CAAC8F,SAAS,CAAC,KAAK,QAAQ,EAAE;UAClG,OAAO9F,mBAAmB,CAAC8F,SAAS,CAAC;QACtC;MACD;MACA,OAAO;QACNpF,kBAAkB,EAAEV,mBAAmB;QACvCQ,yBAAyB,EAAEuE;MAC5B,CAAC;IACF;IACA;AACD;AACA;AACA;AACA;AACA;AACA;AACA,OAPC;IAAA,OAUAgB,mCAAmC,GAFnC,6CAEoCC,oBAAyB,EAAEC,SAAiB,EAAEC,WAAmB,EAAE;MACtG,IAAIX,KAAK;MACT,MAAMrB,aAAkB,GAAG,CAAC,CAAC;MAC7B,MAAMiC,gCAAqC,GAAG,CAAC,CAAC;MAChD,IAAInB,oBAAoB,EAAEC,iBAAiB,EAAEmB,gBAAgB,EAAEf,gBAAgB,EAAEG,cAAc;MAE/F,SAAShB,yBAAyB,CAACC,YAAiB,EAAE;QACrD,IAAIC,qBAAqB;QACzB,KAAK,IAAIC,IAAI,IAAIF,YAAY,EAAE;UAC9B,IAAIA,YAAY,CAACE,IAAI,CAAC,EAAE;YACvB,IAAIA,IAAI,CAAC0B,QAAQ,CAAC,GAAG,CAAC,EAAE;cACvB3B,qBAAqB,GAAGC,IAAI,CAAC,CAAC;cAC9B,MAAM2B,UAAU,GAAG3B,IAAI,CAACN,KAAK,CAAC,GAAG,CAAC;cAClCM,IAAI,GAAG2B,UAAU,CAACA,UAAU,CAAC1G,MAAM,GAAG,CAAC,CAAC;YACzC,CAAC,MAAM;cACN8E,qBAAqB,GAAGuB,SAAS;YAClC;YACA,IAAI,CAAC/B,aAAa,CAACS,IAAI,CAAC,EAAE;cACzB;cACAT,aAAa,CAACS,IAAI,CAAC,GAAG,EAAE;YACzB;;YAEA;YACAT,aAAa,CAACS,IAAI,CAAC,CAAClE,IAAI,CAACiE,qBAAqB,CAAC;UAChD;QACD;MACD;MAEAF,yBAAyB,CAACwB,oBAAoB,CAAC;MAC/C,KAAK,MAAMb,YAAY,IAAIjB,aAAa,EAAE;QACzC,MAAMkB,iBAAiB,GAAGlB,aAAa,CAACiB,YAAY,CAAC;QAErD,IAAIC,iBAAiB,CAACxF,MAAM,GAAG,CAAC,EAAE;UACjC;UACA,KAAK,IAAI0F,CAAC,GAAG,CAAC,EAAEA,CAAC,IAAIF,iBAAiB,CAACxF,MAAM,GAAG,CAAC,EAAE0F,CAAC,EAAE,EAAE;YACvDC,KAAK,GAAGH,iBAAiB,CAACE,CAAC,CAAC;YAC5B,IAAIC,KAAK,KAAKU,SAAS,EAAE;cACxBG,gBAAgB,GAAI,GAAEH,SAAU,IAAGd,YAAa,EAAC;cACjDK,cAAc,GAAGL,YAAY;cAC7BH,oBAAoB,GAAGG,YAAY;cACnC,IAAIe,WAAW,IAAIA,WAAW,CAACG,QAAQ,CAAClB,YAAY,CAAC,EAAE;gBACtDa,oBAAoB,CAAE,cAAab,YAAa,EAAC,CAAC,GAAGa,oBAAoB,CAACb,YAAY,CAAC;cACxF;YACD,CAAC,MAAM;cACNK,cAAc,GAAGD,KAAK;cACtBa,gBAAgB,GAAK,GAAEH,SAAU,IAAGV,KAAM,EAAC,CAASgB,UAAU,CAAC,KAAK,EAAE,EAAE,CAAC;cACzEtB,iBAAiB,GAAGM,KAAK;YAC1B;YACAS,oBAAoB,CACnBI,gBAAgB,CACd/B,KAAK,CAAC,GAAG,CAAC,CACVC,MAAM,CAAC,UAAUqB,MAAW,EAAE;cAC9B,OAAOA,MAAM,IAAI,EAAE;YACpB,CAAC,CAAC,CACDC,IAAI,CAAC,GAAG,CAAC,CACX,GAAGI,oBAAoB,CAACR,cAAc,CAAC;YACxC,OAAOQ,oBAAoB,CAACT,KAAK,CAAC;UACnC;UAEAF,gBAAgB,GAAGL,oBAAoB,IAAIC,iBAAiB;UAC5De,oBAAoB,CAACb,YAAY,CAAC,GAAGa,oBAAoB,CAACX,gBAAgB,CAAC;QAC5E,CAAC,MAAM;UACN;UACAE,KAAK,GAAGH,iBAAiB,CAAC,CAAC,CAAC;UAC5BgB,gBAAgB,GACfb,KAAK,KAAKU,SAAS,GAAI,GAAEA,SAAU,IAAGd,YAAa,EAAC,GAAK,GAAEc,SAAU,IAAGV,KAAM,EAAC,CAASgB,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC;UAC5GJ,gCAAgC,CAAChB,YAAY,CAAC,GAAGiB,gBAAgB,CAC/D/B,KAAK,CAAC,GAAG,CAAC,CACVC,MAAM,CAAC,UAAUqB,MAAW,EAAE;YAC9B,OAAOA,MAAM,IAAI,EAAE;UACpB,CAAC,CAAC,CACDC,IAAI,CAAC,GAAG,CAAC;UACX,IAAIM,WAAW,IAAIA,WAAW,CAACG,QAAQ,CAAClB,YAAY,CAAC,EAAE;YACtDa,oBAAoB,CAAE,cAAab,YAAa,EAAC,CAAC,GAAGa,oBAAoB,CAACb,YAAY,CAAC;UACxF;QACD;MACD;MAEA,OAAO;QACNqB,gBAAgB,EAAER,oBAAoB;QACtCS,+BAA+B,EAAEN;MAClC,CAAC;IACF;;IAEA;AACD;AACA;AACA;AACA,OAJC;IAAA,OAOAtE,iBAAiB,GAFjB,6BAEoB;MACnB,OAAOT,SAAS;IACjB;IACA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAvBC;IAAA,OA0BAsF,8BAA8B,GAF9B,wCAGCtI,eAAuB,EACvBC,OAAe,EACfC,qBAMC,EACA;MAAA;MACD,IAAIA,qBAAqB,aAArBA,qBAAqB,eAArBA,qBAAqB,CAAEqI,qBAAqB,IAAI,0BAAArI,qBAAqB,CAACqI,qBAAqB,0DAA3C,sBAA6C/G,MAAM,KAAI,CAAC,EAAE;QAC7G,IAAIgH,wBAAgC;QACpC,MAAMtH,WAAW,GAAG;UACnBuH,OAAO,EAAE,YAAY;YACpB;YACAD,wBAAwB,CAACE,KAAK,EAAE;UACjC,CAAC;UACDC,UAAU,EAAE,MAAM;YACjB;YACAzI,qBAAqB,CAACI,kBAAkB,GAAGJ,qBAAqB,CAAC0I,kBAAkB;YACnFJ,wBAAwB,CAACE,KAAK,EAAE;YAChC,IAAI,CAAC3I,QAAQ,CAACC,eAAe,EAAEC,OAAO,EAAEC,qBAAqB,CAAC;UAC/D;QACD,CAAC;QACD,MAAM2I,mBAAmB,GAAG,YAAY;UACvC,IAAIC,cAAc;UAClB,MAAMC,cAAc,GAAG7I,qBAAqB,CAACqI,qBAAqB,CAAC/G,MAAM;YACxEwH,mBAAmB,GAAG,EAAE;UACzB,KAAK,IAAI9B,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGhH,qBAAqB,CAACqI,qBAAqB,CAAC/G,MAAM,EAAE0F,CAAC,EAAE,EAAE;YAC5E4B,cAAc,GAAG5I,qBAAqB,CAACqI,qBAAqB,CAACrB,CAAC,CAAC,CAACrF,SAAS,EAAE;YAC3EmH,mBAAmB,CAAC3G,IAAI,CAACyG,cAAc,CAAC;UACzC;UACA,MAAMG,wBAAwB,GAAG,IAAIC,SAAS,CAACF,mBAAmB,CAAC;UACnE,MAAMG,OAAO,GAAG,IAAID,SAAS,CAAC;YAAEE,KAAK,EAAEL,cAAc;YAAEM,KAAK,EAAEnJ,qBAAqB,CAACmJ;UAAM,CAAC,CAAC;UAC5Fb,wBAAwB,CAACc,QAAQ,CAACL,wBAAwB,EAAE,eAAe,CAAC;UAC5ET,wBAAwB,CAACc,QAAQ,CAACH,OAAO,EAAE,QAAQ,CAAC;UACpDX,wBAAwB,CAACe,IAAI,EAAE;QAChC,CAAC;QACD;QACA,MAAMC,aAAa,GAAG,oCAAoC;QAC1D,MAAMC,eAAe,GAAGC,oBAAoB,CAACC,YAAY,CAACH,aAAa,EAAE,UAAU,CAAC;QACpF,MAAM7G,MAAM,GAAG,IAAI,CAAC9C,MAAM,CAACJ,QAAQ,EAAE;QACrC,MAAM0F,UAAU,GAAGxC,MAAM,CAACjD,YAAY,EAAoB;QAC1D,MAAMkK,cAAc,GAAG1J,qBAAqB,CAACqI,qBAAqB,CAAC,CAAC,CAAC,CAACsB,gBAAgB,EAAE;QACxF,MAAMjH,UAAU,GAAI,GAAEgH,cAAc,CAACE,MAAM,CAAC,CAAC,EAAEF,cAAc,CAACG,OAAO,CAAC,GAAG,CAAC,CAAE,GAAE;QAC9EC,OAAO,CAACC,OAAO,CACdC,eAAe,CAACC,OAAO,CACtBV,eAAe,EACf;UAAEW,IAAI,EAAEZ;QAAc,CAAC,EACvB;UACCa,eAAe,EAAE;YAChBC,UAAU,EAAEnF,UAAU,CAACoF,oBAAoB,CAAC3H,UAAU;UACvD,CAAC;UACD4H,MAAM,EAAE;YACPF,UAAU,EAAEnF,UAAU;YACtBsF,SAAS,EAAEtF;UACZ;QACD,CAAC,CACD,CACD,CACCuF,IAAI,CAAC,UAAUC,SAAc,EAAE;UAC/B,OAAOC,QAAQ,CAACC,IAAI,CAAC;YAAEC,UAAU,EAAEH,SAAS;YAAEI,UAAU,EAAE7J;UAAY,CAAC,CAAC;QACzE,CAAC,CAAC,CACDwJ,IAAI,CAAEM,QAAa,IAAK;UACxBxC,wBAAwB,GAAGwC,QAAQ;UACnC,IAAI,CAAClL,OAAO,EAAE,CAACmL,YAAY,CAACD,QAAQ,CAAC;UACrCnC,mBAAmB,EAAE;QACtB,CAAC,CAAC,CACDqC,KAAK,CAAC,YAAY;UAClBC,GAAG,CAACtG,KAAK,CAAC,OAAO,CAAC;QACnB,CAAC,CAAC;MACJ,CAAC,MAAM;QACN,IAAI,CAAC9E,QAAQ,CAACC,eAAe,EAAEC,OAAO,EAAEC,qBAAqB,CAAC;MAC/D;IACD,CAAC;IAAA,OACDoD,0BAA0B,GAA1B,oCAA2BhC,iBAAsB,EAAE;MAClDA,iBAAiB,CAAC8J,kBAAkB,CAAC,gBAAgB,CAAC;MACtD9J,iBAAiB,CAAC8J,kBAAkB,CAAC,qBAAqB,CAAC;MAC3D9J,iBAAiB,CAAC8J,kBAAkB,CAAC,eAAe,CAAC;IACtD;IACA;AACD;AACA;AACA;AACA,OAJC;IAAA,OAMAvI,YAAY,GADZ,wBACe;MACd,OAAQ,IAAI,CAAChD,MAAM,CAACgE,WAAW,EAAE,CAASwH,SAAS;IACpD;IACA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;IACC;IAAA;IAAA,OAGApJ,mBAAmB,GAFnB,6BAEoBqJ,WAAgB,EAAExJ,SAAiB,EAAE;MACxD,IAAIwJ,WAAW,EAAE;QAChB,MAAM;UAAEC,iBAAiB;UAAEC;QAAiB,CAAC,GAAG,IAAI,CAACC,cAAc,CAClE3J,SAAS,EACT,IAAI,CAACxC,IAAI,CAACQ,OAAO,EAAE,EACnB,IAAI,CAACR,IAAI,CAACC,eAAe,EAAE,CAACmM,cAAc,EAAE,CAC5C;QACD,MAAMC,WAAW,GAAGC,MAAM,CAACC,IAAI,CAACP,WAAW,CAAC;QAC5C,IAAIK,WAAW,CAACnK,MAAM,EAAE;UACvB,OAAO8J,WAAW,CAAC,gBAAgB,CAAC;UACpC,OAAOA,WAAW,CAAC,qBAAqB,CAAC;UACzC,OAAOA,WAAW,CAAC,eAAe,CAAC;UACnC,KAAK,IAAIQ,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,WAAW,CAACnK,MAAM,EAAEsK,CAAC,EAAE,EAAE;YAC5C,IAAIR,WAAW,CAACK,WAAW,CAACG,CAAC,CAAC,CAAC,IAAI,OAAOR,WAAW,CAACK,WAAW,CAACG,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE;cACnF,IAAI,CAAC7J,mBAAmB,CAACqJ,WAAW,CAACK,WAAW,CAACG,CAAC,CAAC,CAAC,EAAG,GAAEhK,SAAU,IAAG6J,WAAW,CAACG,CAAC,CAAE,EAAC,CAAC;YACxF;YACA,MAAMC,KAAK,GAAGJ,WAAW,CAACG,CAAC,CAAC;YAC5B,IAAIC,KAAK,CAAChC,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,EAAE;cACtC,OAAOuB,WAAW,CAACK,WAAW,CAACG,CAAC,CAAC,CAAC;cAClC;YACD;YACA,IAAI,CAACE,iBAAiB,CAAC,CAAC,GAAGT,iBAAiB,EAAE,GAAGC,gBAAgB,CAAC,EAAEG,WAAW,CAACG,CAAC,CAAC,EAAER,WAAW,CAAC;YAChG,MAAMW,oBAAoB,GAAG,IAAI,CAACC,uBAAuB,CAACH,KAAK,EAAEjK,SAAS,EAAEwJ,WAAW,EAAE,IAAI,CAAC9L,WAAW,CAAC;YAC1G,IAAIyM,oBAAoB,EAAE;cACzB,IACCA,oBAAoB,CAAC,6DAA6D,CAAC,IACnFA,oBAAoB,CAAC,yDAAyD,CAAC,IAC/EA,oBAAoB,CAAC,2CAA2C,CAAC,EAChE;gBACD,OAAOX,WAAW,CAACS,KAAK,CAAC;cAC1B,CAAC,MAAM,IAAIE,oBAAoB,CAAC,6CAA6C,CAAC,EAAE;gBAC/E,MAAME,aAAa,GAAGF,oBAAoB,CAAC,6CAA6C,CAAC;gBACzF,IAAIE,aAAa,CAAC,aAAa,CAAC,IAAIA,aAAa,CAAC,aAAa,CAAC,CAAClG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,cAAc,EAAE;kBAClG,OAAOqF,WAAW,CAACS,KAAK,CAAC;gBAC1B,CAAC,MAAM,IACNI,aAAa,CAAC,OAAO,CAAC,IACtB,IAAI,CAACC,+BAA+B,CAACD,aAAa,CAAC,OAAO,CAAC,EAAEb,WAAW,CAAC,EACxE;kBACD,OAAOA,WAAW,CAACS,KAAK,CAAC;gBAC1B;cACD;YACD;UACD;QACD;MACD;MACA,OAAOT,WAAW;IACnB;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA,OANC;IAAA,OAOAU,iBAAiB,GAAjB,2BAAkBK,UAAgC,EAAEN,KAAa,EAAET,WAAgB,EAAE;MACpF,IAAIe,UAAU,IAAIA,UAAU,CAACtC,OAAO,CAACgC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE;QACjD,OAAOT,WAAW,CAACS,KAAK,CAAC;MAC1B;IACD;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OARC;IAAA,OASAG,uBAAuB,GAAvB,iCAAwBH,KAAa,EAAEjK,SAAiB,EAAEwJ,WAAgB,EAAEnG,UAA0B,EAAE;MACvG,IAAImG,WAAW,CAACS,KAAK,CAAC,IAAIjK,SAAS,IAAI,CAACA,SAAS,CAACmG,QAAQ,CAAC,WAAW,CAAC,EAAE;QAAA;QACxE,MAAM7H,QAAQ,GAAG+E,UAAU,CAACoF,oBAAoB,CAAE,GAAEzI,SAAU,IAAGiK,KAAM,EAAC,CAAmB;QAC3F,MAAMO,YAAY,GAAGC,kBAAkB,CAACC,2BAA2B,CAACpM,QAAQ,CAAC;QAC7E,OAAOkM,YAAY,aAAZA,YAAY,gDAAZA,YAAY,CAAEG,YAAY,oFAA1B,sBAA4BC,WAAW,2DAAvC,uBAAyCC,YAAY;MAC7D;MACA,OAAO,IAAI;IACZ;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA;AACA,OAPC;IAAA,OAQAlB,cAAc,GAAd,wBAAe3J,SAAiB,EAAEb,KAAW,EAAE2L,YAAyB,EAAE;MACzE,MAAMC,gBAAgB,GAAG,IAAI,CAACC,oBAAoB,CAAChL,SAAS,EAAEb,KAAK,EAAE2L,YAAY,CAAC;MAClF,MAAMG,iBAAiB,GAAG,IAAIC,iBAAiB,CAACH,gBAAgB,CAACI,aAAa,EAAE,EAAEJ,gBAAgB,CAAC;MACnG,MAAMK,oBAAoB,GAAGH,iBAAiB,CAACG,oBAAoB,EAAE;MACrE,IAAI3B,iBAAiB,GAAG,EAAE;QACzBC,gBAAgB,GAAG,EAAE;MACtB,IAAI0B,oBAAoB,EAAE;QACzB3B,iBAAiB,GAAGwB,iBAAiB,CAACI,oBAAoB,EAAE;QAC5D,IAAI5B,iBAAiB,CAAC/J,MAAM,EAAE;UAC7B+J,iBAAiB,GAAGA,iBAAiB,CAAC6B,GAAG,CAAEC,QAAa,IAAK;YAC5D,OAAOA,QAAQ,CAACC,IAAI,IAAID,QAAQ,CAACE,KAAK;UACvC,CAAC,CAAC;QACH;QACA/B,gBAAgB,GAAGuB,iBAAiB,CAACS,6BAA6B,EAAE;QACpE,IAAIhC,gBAAgB,CAAChK,MAAM,EAAE;UAC5BgK,gBAAgB,GAAGA,gBAAgB,CAAC4B,GAAG,CAAEK,eAAoB,IAAK;YACjE,OAAOA,eAAe,CAACC,SAAS;UACjC,CAAC,CAAC;QACH;MACD;MACA,OAAO;QAAEnC,iBAAiB;QAAEC;MAAiB,CAAC;IAC/C;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA;AACA,OAPC;IAAA,OAQAsB,oBAAoB,GAApB,8BAAqBhL,SAAiB,EAAEb,KAAW,EAAE2L,YAAyB,EAAE;MAC/E,MAAMe,SAAc,GAAG1M,KAAK,CAAC4C,WAAW,EAAE;MAC1C,IAAIjB,UAAU,GAAG+K,SAAS,CAACtC,SAAS;MACpC,MAAMtF,YAAY,GAAG4H,SAAS,CAACC,WAAW;MAC1C,IAAI7H,YAAY,KAAK,CAACnD,UAAU,IAAIA,UAAU,CAACqF,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE;QAC9DrF,UAAU,GAAG+K,SAAS,aAATA,SAAS,uBAATA,SAAS,CAAEE,eAAe,CAAC5H,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;MACtD;MACA,OAAO6H,WAAW,CAACC,0BAA0B,CAC5CjM,SAAS,EACTb,KAAK,CAACxB,QAAQ,EAAE,CAACC,YAAY,EAAE,EAC/BkD,UAAU,EACVgK,YAAY,CACZ;IACF;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA,OANC;IAAA,OAOAR,+BAA+B,GAA/B,yCAAgC4B,iBAAyB,EAAEC,UAAe,EAAE;MAC3E,IAAIC,aAAa,GAAG,KAAK;MACzB,MAAMC,MAAM,GAAGH,iBAAiB,CAAC/H,KAAK,CAAC,GAAG,CAAC;MAC3C;MACA,IAAIkI,MAAM,CAAC3M,MAAM,GAAG,CAAC,EAAE;QACtB0M,aAAa,GACZD,UAAU,CAACE,MAAM,CAAC,CAAC,CAAC,CAAC,IAAIF,UAAU,CAACE,MAAM,CAAC,CAAC,CAAC,CAAC,CAACC,cAAc,CAACD,MAAM,CAAC,CAAC,CAAC,CAAC,IAAIF,UAAU,CAACE,MAAM,CAAC,CAAC,CAAC,CAAC,CAACA,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;MACpH,CAAC,MAAM;QACND,aAAa,GAAGD,UAAU,CAACD,iBAAiB,CAAC,KAAK,CAAC;MACpD;MACA,OAAOE,aAAa;IACrB;IACA;AACD;AACA;AACA;AACA;AACA;AACA,OANC;IAAA,OAOA7K,4BAA4B,GAA5B,sCAA6B/B,iBAAmC,EAAE+M,SAA0B,EAAE;MAC7F,MAAMC,SAAS,GAAG,OAAOD,SAAS,KAAK,QAAQ,GAAGE,IAAI,CAACC,KAAK,CAACH,SAAS,CAAC,GAAGA,SAAS;MACnF,KAAK,IAAInH,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGoH,SAAS,CAAC9M,MAAM,EAAE0F,CAAC,EAAE,EAAE;QAC1C,MAAMuH,cAAc,GAClBH,SAAS,CAACpH,CAAC,CAAC,CAAC,eAAe,CAAC,IAAIoH,SAAS,CAACpH,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,eAAe,CAAC,IAC/EoH,SAAS,CAACpH,CAAC,CAAC,CAAC,+CAA+C,CAAC,IAC7DoH,SAAS,CAACpH,CAAC,CAAC,CAAC,+CAA+C,CAAC,CAAC,OAAO,CAAE;QACzE,MAAMwH,uBAAuB,GAC5BJ,SAAS,CAACpH,CAAC,CAAC,CAAC,wBAAwB,CAAC,IAAIoH,SAAS,CAACpH,CAAC,CAAC,CAAC,wDAAwD,CAAC;QACjH,MAAMyH,aAAa,GAAGrN,iBAAiB,CAACsN,eAAe,CAACH,cAAc,CAAC;QACvE,IAAIE,aAAa,EAAE;UAClB;UACArN,iBAAiB,CAAC8J,kBAAkB,CAACqD,cAAc,CAAC;UACpDnN,iBAAiB,CAACuN,mBAAmB,CAACH,uBAAuB,EAAEC,aAAa,CAAC;QAC9E;MACD;MACA,OAAOrN,iBAAiB;IACzB;IACA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OARC;IAAA,OAWAwN,gBAAgB,GAFhB,0BAEiBC,SAAiB,EAAE7O,qBAA0B,EAAE;MAAA;MAC/D,IAAI8O,UAA6B;MACjC,MAAMC,cAAc,GAAG,IAAI,CAAC3P,IAAI,CAACC,eAAe,EAAE,CAAC2P,gBAAgB,CAAC,SAAS,CAAC;QAC7EC,SAAS,4BAAGF,cAAc,CAACG,eAAe,oFAA9B,sBAAgCC,SAAS,2DAAzC,uBAA4CN,SAAS,CAAC;MACnE,IAAI,CAACI,SAAS,EAAE;QACfhE,GAAG,CAACtG,KAAK,CAAC,uCAAuC,CAAC;QAClD;MACD;MACA,MAAM7E,eAAe,GAAGmP,SAAS,CAACpO,cAAc;QAC/Cd,OAAO,GAAGkP,SAAS,CAACnO,MAAM;QAC1BsO,cAAc,GAAGH,SAAS,CAACI,UAAU,IAAI,IAAI,CAACC,iBAAiB,CAACL,SAAS,CAACI,UAAU,CAAC;MAEtF,IAAIrP,qBAAqB,EAAE;QAC1B8O,UAAU,GAAG,EAAE;QACfpD,MAAM,CAACC,IAAI,CAAC3L,qBAAqB,CAAC,CAACuB,OAAO,CAAC,UAAUgO,GAAW,EAAE;UACjE,IAAIC,OAAY;UAChB,IAAIlP,KAAK,CAACC,OAAO,CAACP,qBAAqB,CAACuP,GAAG,CAAC,CAAC,EAAE;YAC9C,MAAME,OAAO,GAAGzP,qBAAqB,CAACuP,GAAG,CAAC;YAC1C,KAAK,IAAIvI,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGyI,OAAO,CAACnO,MAAM,EAAE0F,CAAC,EAAE,EAAE;cAAA;cACxCwI,OAAO,GAAG,CAAC,CAAC;cACZA,OAAO,CAACD,GAAG,CAAC,GAAGE,OAAO,CAACzI,CAAC,CAAC;cACzB,eAAA8H,UAAU,gDAAV,YAAY3M,IAAI,CAACqN,OAAO,CAAC;YAC1B;UACD,CAAC,MAAM;YAAA;YACNA,OAAO,GAAG,CAAC,CAAC;YACZA,OAAO,CAACD,GAAG,CAAC,GAAGvP,qBAAqB,CAACuP,GAAG,CAAC;YACzC,gBAAAT,UAAU,iDAAV,aAAY3M,IAAI,CAACqN,OAAO,CAAC;UAC1B;QACD,CAAC,CAAC;MACH;MACA,IAAIV,UAAU,IAAIM,cAAc,EAAE;QACjCpP,qBAAqB,GAAG;UACvBI,kBAAkB,EAAE;YACnBiC,IAAI,EAAEyM,UAAU,IAAIM;UACrB;QACD,CAAC;MACF;MACA,IAAI,CAAChQ,IAAI,CAACkE,sBAAsB,CAACzD,QAAQ,CAACC,eAAe,EAAEC,OAAO,EAAEC,qBAAqB,CAAC;IAC3F;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA,OANC;IAAA,OAOAgD,oBAAoB,GAApB,8BAAqB5B,iBAAmC,EAAEV,eAAoB,EAAE;MAC/E,MAAMkH,WAAW,GAAG8D,MAAM,CAACC,IAAI,CAACjL,eAAe,CAAC;MAChD,MAAMgP,iBAAiB,GAAGtO,iBAAiB,CAACuO,6BAA6B,EAAE;MAC3E/H,WAAW,CAACrG,OAAO,CAAC,UAAUgO,GAAW,EAAE;QAC1C,IAAI,CAACG,iBAAiB,CAAC3H,QAAQ,CAACwH,GAAG,CAAC,EAAE;UACrCnO,iBAAiB,CAACwO,eAAe,CAACL,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE7O,eAAe,CAAC6O,GAAG,CAAC,CAAC;QACxE;MACD,CAAC,CAAC;MACF,OAAOnO,iBAAiB;IACzB;IACA;AACD;AACA;AACA;AACA;AACA;AACA,OANC;IAAA,OASAkO,iBAAiB,GAFjB,2BAEkBO,eAAoB,EAAE;MACvC,MAAMC,cAAmB,GAAG,CAAC,CAAC;MAC9B,IAAID,eAAe,EAAE;QACpB,MAAMjI,WAAW,GAAG8D,MAAM,CAACC,IAAI,CAACkE,eAAe,CAAC,IAAI,EAAE;QACtD,IAAIjI,WAAW,CAACtG,MAAM,GAAG,CAAC,EAAE;UAC3BsG,WAAW,CAACrG,OAAO,CAAC,UAAUgO,GAAW,EAAE;YAC1C,MAAMQ,QAAQ,GAAGF,eAAe,CAACN,GAAG,CAAC;YACrC,IAAIQ,QAAQ,CAACC,KAAK,IAAID,QAAQ,CAACC,KAAK,CAACA,KAAK,IAAID,QAAQ,CAACC,KAAK,CAACC,MAAM,KAAK,OAAO,EAAE;cAChF,IAAI,CAACH,cAAc,CAACP,GAAG,CAAC,EAAE;gBACzBO,cAAc,CAACP,GAAG,CAAC,GAAGQ,QAAQ,CAACC,KAAK,CAACA,KAAK;cAC3C;YACD;UACD,CAAC,CAAC;QACH;MACD;MACA,OAAOF,cAAc;IACtB;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OARC;IAAA,OAYAI,8BAA8B,GAF9B,wCAE+BlP,WAA2B,EAAEmP,eAAuB,EAAEjQ,QAAa,EAAEkQ,WAAmB,EAAE;MACxH,MAAMC,UAAU,GAAIrP,WAAW,CAAC3B,eAAe,EAAE,CAASiR,iBAAiB,EAAE,CAACC,YAAY,EAAE;MAC5F,MAAMC,gBAAgB,GAAGH,UAAU,CAACF,eAAe,CAAC;MACpD,IAAIxP,8BAA8B;MAClC,IAAI6P,gBAAgB,IAAIA,gBAAgB,CAAC3P,cAAc,IAAI2P,gBAAgB,CAAC1P,MAAM,EAAE;QACnF,MAAM2P,kBAAuB,GAAG;UAC/BC,OAAO,EAAE,CAAC;QACX,CAAC;QACD,MAAMC,uBAA4B,GAAG,CAAC,CAAC;QACvC,IAAI/O,SAAS;QAEb,IAAI1B,QAAQ,EAAE;UACb,IAAIA,QAAQ,CAACuB,GAAG,IAAIvB,QAAQ,CAACuB,GAAG,CAAC,+BAA+B,CAAC,EAAE;YAClEG,SAAS,GAAGuD,WAAW,CAACyL,qBAAqB,CAAC1Q,QAAQ,CAAC;YACvDA,QAAQ,GAAG,CAACA,QAAQ,CAAC;UACtB,CAAC,MAAM;YACN0B,SAAS,GAAGuD,WAAW,CAACyL,qBAAqB,CAAC1Q,QAAQ,CAAC,CAAC,CAAC,CAAC;UAC3D;UACAyQ,uBAAuB,CAAC/O,SAAS,CAAC,GAAG,MAAM;UAC3C6O,kBAAkB,CAAC,YAAY,CAAC,GAAGE,uBAAuB;QAC3D;QAEA,IAAIP,WAAW,EAAE;UAChB,MAAM/J,IAAI,GAAI,GAAEmK,gBAAgB,CAAC3P,cAAe,IAAG2P,gBAAgB,CAAC1P,MAAO,EAAC;UAC5E2P,kBAAkB,CAACC,OAAO,CAACrK,IAAI,CAAC,GAAG,CAAC,CAAC;UACrCoK,kBAAkB,CAACC,OAAO,CAACrK,IAAI,CAAC,CAAC+J,WAAW,CAAC,GAAG,MAAM;QACvD;QACA,IAAII,gBAAgB,IAAIA,gBAAgB,CAACnB,UAAU,EAAE;UACpD,MAAMG,OAAO,GAAGgB,gBAAgB,CAACnB,UAAU,IAAI,IAAI,CAACC,iBAAiB,CAACkB,gBAAgB,CAACnB,UAAU,CAAC;UAClG,IAAI3D,MAAM,CAACC,IAAI,CAAC6D,OAAO,CAAC,CAAClO,MAAM,GAAG,CAAC,EAAE;YACpCX,8BAA8B,GAAG6O,OAAO;UACzC;QACD;QAEAxO,WAAW,CAACsC,sBAAsB,CAACzD,QAAQ,CAAC2Q,gBAAgB,CAAC3P,cAAc,EAAE2P,gBAAgB,CAAC1P,MAAM,EAAE;UACrGV,kBAAkB,EAAEF,QAAQ;UAC5BuD,iBAAiB,EAAEgN,kBAAkB;UACrC9P,8BAA8B,EAAEA;QACjC,CAAC,CAAC;;QAEF;QACA,OAAOmJ,OAAO,CAACC,OAAO,EAAE;MACzB,CAAC,MAAM;QACN,MAAM,IAAIjF,KAAK,CAAE,mBAAkBqL,eAAgB,uDAAsD,CAAC;MAC3G;IACD,CAAC;IAAA;EAAA,EAp2B0CU,mBAAmB;EAAA,OAu2BhDpS,6BAA6B;AAAA"}