@sapui5/sap.fe.core 1.93.3 → 1.97.0

package/src/sap/fe/core/converters/controls/ListReport/FilterBar.js

@@ -0,0 +1,487 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["../../ManifestSettings", "sap/fe/core/converters/controls/Common/Table", "sap/fe/core/converters/helpers/ConfigurableObject", "sap/fe/core/converters/controls/ListReport/VisualFilters", "sap/fe/core/helpers/BindingExpression", "../Common/DataVisualization", "sap/fe/core/converters/helpers/Key", "sap/fe/core/converters/helpers/IssueManager"], function (ManifestSettings, Table, ConfigurableObject, VisualFilters, BindingExpression, DataVisualization, Key, IssueManager) {
+  "use strict";
+
+  var _exports = {};
+  var IssueCategory = IssueManager.IssueCategory;
+  var IssueSeverity = IssueManager.IssueSeverity;
+  var IssueType = IssueManager.IssueType;
+  var KeyHelper = Key.KeyHelper;
+  var getSelectionVariant = DataVisualization.getSelectionVariant;
+  var compileBinding = BindingExpression.compileBinding;
+  var annotationExpression = BindingExpression.annotationExpression;
+  var getVisualFilters = VisualFilters.getVisualFilters;
+  var Placement = ConfigurableObject.Placement;
+  var insertCustomElements = ConfigurableObject.insertCustomElements;
+  var isFilteringCaseSensitive = Table.isFilteringCaseSensitive;
+  var getSelectionVariantConfiguration = Table.getSelectionVariantConfiguration;
+  var TemplateType = ManifestSettings.TemplateType;
+  var AvailabilityType = ManifestSettings.AvailabilityType;
+
+  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+  /**
+   * Enter all DataFields of a given FieldGroup into the filterFacetMap.
+   *
+   * @param {AnnotationTerm<FieldGroupType>} fieldGroup
+   * @returns {Record<string, FilterGroup>} The map of facets for the given fieldGroup
+   */
+  function getFieldGroupFilterGroups(fieldGroup) {
+    var filterFacetMap = {};
+    fieldGroup.Data.forEach(function (dataField) {
+      if (dataField.$Type === "com.sap.vocabularies.UI.v1.DataField") {
+        var _fieldGroup$annotatio, _fieldGroup$annotatio2;
+
+        filterFacetMap[dataField.Value.path] = {
+          group: fieldGroup.fullyQualifiedName,
+          groupLabel: compileBinding(annotationExpression(fieldGroup.Label || ((_fieldGroup$annotatio = fieldGroup.annotations) === null || _fieldGroup$annotatio === void 0 ? void 0 : (_fieldGroup$annotatio2 = _fieldGroup$annotatio.Common) === null || _fieldGroup$annotatio2 === void 0 ? void 0 : _fieldGroup$annotatio2.Label) || fieldGroup.qualifier)) || fieldGroup.qualifier
+        };
+      }
+    });
+    return filterFacetMap;
+  }
+
+  function getExcludedFilterProperties(selectionVariants) {
+    return selectionVariants.reduce(function (previousValue, selectionVariant) {
+      selectionVariant.propertyNames.forEach(function (propertyName) {
+        previousValue[propertyName] = true;
+      });
+      return previousValue;
+    }, {});
+  }
+  /**
+   * Check that all the tables for a dedicated entityset are configured as analytical table.
+   * @param {TableVisualization[]} listReportTables List Report tables
+   * @param {string} contextPath
+   * @returns {boolean} Is FilterBar search field hidden or not
+   */
+
+
+  function checkAllTableForEntitySetAreAnalytical(listReportTables, contextPath) {
+    if (contextPath && listReportTables.length > 0) {
+      return listReportTables.every(function (visualization) {
+        return visualization.enableAnalytics && contextPath === visualization.annotation.collection;
+      });
+    }
+
+    return false;
+  }
+
+  function getSelectionVariants(lrTableVisualizations, converterContext) {
+    var selectionVariantPaths = [];
+    return lrTableVisualizations.map(function (visualization) {
+      var tableFilters = visualization.control.filters;
+      var tableSVConfigs = [];
+
+      for (var key in tableFilters) {
+        if (Array.isArray(tableFilters[key].paths)) {
+          var paths = tableFilters[key].paths;
+          paths.forEach(function (path) {
+            if (path && path.annotationPath && selectionVariantPaths.indexOf(path.annotationPath) === -1) {
+              selectionVariantPaths.push(path.annotationPath);
+              var selectionVariantConfig = getSelectionVariantConfiguration(path.annotationPath, converterContext);
+
+              if (selectionVariantConfig) {
+                tableSVConfigs.push(selectionVariantConfig);
+              }
+            }
+          });
+        }
+      }
+
+      return tableSVConfigs;
+    }).reduce(function (svConfigs, selectionVariant) {
+      return svConfigs.concat(selectionVariant);
+    }, []);
+  }
+  /**
+   * Returns the condition path required for the condition model. It looks like follow:
+   * <1:N-PropertyName>*\/<1:1-PropertyName>/<PropertyName>.
+   *
+   * @param entityType The root EntityTy[e
+   * @param propertyPath The full path to the target property
+   * @returns {string} The formatted condition path
+   */
+
+
+  var _getConditionPath = function (entityType, propertyPath) {
+    var parts = propertyPath.split("/");
+    var partialPath;
+    var key = "";
+
+    while (parts.length) {
+      var part = parts.shift();
+      partialPath = partialPath ? partialPath + "/" + part : part;
+      var property = entityType.resolvePath(partialPath);
+
+      if (property._type === "NavigationProperty" && property.isCollection) {
+        part += "*";
+      }
+
+      key = key ? key + "/" + part : part;
+    }
+
+    return key;
+  };
+
+  var _createFilterSelectionField = function (entityType, property, fullPropertyPath, includeHidden, converterContext) {
+    var _property$annotations, _property$annotations2, _property$annotations3;
+
+    // ignore complex property types and hidden annotated ones
+    if (property !== undefined && property.targetType === undefined && (includeHidden || ((_property$annotations = property.annotations) === null || _property$annotations === void 0 ? void 0 : (_property$annotations2 = _property$annotations.UI) === null || _property$annotations2 === void 0 ? void 0 : (_property$annotations3 = _property$annotations2.Hidden) === null || _property$annotations3 === void 0 ? void 0 : _property$annotations3.valueOf()) !== true)) {
+      var _property$annotations4, _property$annotations5, _property$annotations6, _property$annotations7, _property$annotations8, _targetEntityType$ann, _targetEntityType$ann2, _targetEntityType$ann3;
+
+      var targetEntityType = converterContext.getAnnotationEntityType(property);
+      return {
+        key: KeyHelper.getSelectionFieldKeyFromPath(fullPropertyPath),
+        annotationPath: converterContext.getAbsoluteAnnotationPath(fullPropertyPath),
+        conditionPath: _getConditionPath(entityType, fullPropertyPath),
+        availability: ((_property$annotations4 = property.annotations) === null || _property$annotations4 === void 0 ? void 0 : (_property$annotations5 = _property$annotations4.UI) === null || _property$annotations5 === void 0 ? void 0 : (_property$annotations6 = _property$annotations5.HiddenFilter) === null || _property$annotations6 === void 0 ? void 0 : _property$annotations6.valueOf()) === true ? AvailabilityType.Hidden : AvailabilityType.Adaptation,
+        label: compileBinding(annotationExpression(((_property$annotations7 = property.annotations.Common) === null || _property$annotations7 === void 0 ? void 0 : (_property$annotations8 = _property$annotations7.Label) === null || _property$annotations8 === void 0 ? void 0 : _property$annotations8.valueOf()) || property.name)),
+        group: targetEntityType.name,
+        groupLabel: compileBinding(annotationExpression((targetEntityType === null || targetEntityType === void 0 ? void 0 : (_targetEntityType$ann = targetEntityType.annotations) === null || _targetEntityType$ann === void 0 ? void 0 : (_targetEntityType$ann2 = _targetEntityType$ann.Common) === null || _targetEntityType$ann2 === void 0 ? void 0 : (_targetEntityType$ann3 = _targetEntityType$ann2.Label) === null || _targetEntityType$ann3 === void 0 ? void 0 : _targetEntityType$ann3.valueOf()) || targetEntityType.name))
+      };
+    }
+
+    return undefined;
+  };
+
+  var _getSelectionFields = function (entityType, navigationPath, properties, includeHidden, converterContext) {
+    var selectionFieldMap = {};
+
+    if (properties) {
+      properties.forEach(function (property) {
+        var propertyPath = property.name;
+        var fullPath = (navigationPath ? navigationPath + "/" : "") + propertyPath;
+
+        var selectionField = _createFilterSelectionField(entityType, property, fullPath, includeHidden, converterContext);
+
+        if (selectionField) {
+          selectionFieldMap[fullPath] = selectionField;
+        }
+      });
+    }
+
+    return selectionFieldMap;
+  };
+
+  var _getSelectionFieldsByPath = function (entityType, propertyPaths, includeHidden, converterContext) {
+    var selectionFields = {};
+
+    if (propertyPaths) {
+      propertyPaths.forEach(function (propertyPath) {
+        var localSelectionFields;
+        var property = entityType.resolvePath(propertyPath);
+
+        if (property === undefined) {
+          return;
+        }
+
+        if (property._type === "NavigationProperty") {
+          // handle navigation properties
+          localSelectionFields = _getSelectionFields(entityType, propertyPath, property.targetType.entityProperties, includeHidden, converterContext);
+        } else if (property.targetType !== undefined) {
+          // handle ComplexType properties
+          localSelectionFields = _getSelectionFields(entityType, propertyPath, property.targetType.properties, includeHidden, converterContext);
+        } else {
+          var navigationPath = propertyPath.includes("/") ? propertyPath.split("/").splice(0, 1).join("/") : "";
+          localSelectionFields = _getSelectionFields(entityType, navigationPath, [property], includeHidden, converterContext);
+        }
+
+        selectionFields = _objectSpread(_objectSpread({}, selectionFields), localSelectionFields);
+      });
+    }
+
+    return selectionFields;
+  };
+
+  var _getFilterField = function (filterFields, propertyPath, converterContext, entityType) {
+    var filterField = filterFields[propertyPath];
+
+    if (filterField) {
+      delete filterFields[propertyPath];
+    } else {
+      filterField = _createFilterSelectionField(entityType, entityType.resolvePath(propertyPath), propertyPath, true, converterContext);
+    }
+
+    if (!filterField) {
+      converterContext.getDiagnostics().addIssue(IssueCategory.Annotation, IssueSeverity.High, IssueType.MISSING_SELECTIONFIELD);
+    } // defined SelectionFields are available by default
+
+
+    if (filterField) {
+      var _entityType$annotatio, _entityType$annotatio2;
+
+      filterField.availability = AvailabilityType.Default;
+      filterField.isParameter = !!((_entityType$annotatio = entityType.annotations) !== null && _entityType$annotatio !== void 0 && (_entityType$annotatio2 = _entityType$annotatio.Common) !== null && _entityType$annotatio2 !== void 0 && _entityType$annotatio2.ResultContext);
+    }
+
+    return filterField;
+  };
+
+  var _getDefaultFilterFields = function (filterFields, aSelectOptions, entityType, converterContext, excludedFilterProperties, annotatedSelectionFields) {
+    var selectionFields = [];
+    var UISelectionFields = {};
+    var properties = entityType.entityProperties; // Using entityType instead of entitySet
+
+    annotatedSelectionFields === null || annotatedSelectionFields === void 0 ? void 0 : annotatedSelectionFields.forEach(function (SelectionField) {
+      UISelectionFields[SelectionField.value] = true;
+    });
+
+    if (aSelectOptions && aSelectOptions.length > 0) {
+      aSelectOptions === null || aSelectOptions === void 0 ? void 0 : aSelectOptions.forEach(function (selectOption) {
+        var propertyName = selectOption.PropertyName;
+        var sPropertyPath = propertyName.value;
+        var UISelectionFields = {};
+        annotatedSelectionFields === null || annotatedSelectionFields === void 0 ? void 0 : annotatedSelectionFields.forEach(function (SelectionField) {
+          UISelectionFields[SelectionField.value] = true;
+        });
+
+        if (!(sPropertyPath in excludedFilterProperties)) {
+          if (!(sPropertyPath in UISelectionFields)) {
+            var _FilterField = _getFilterField(filterFields, sPropertyPath, converterContext, entityType);
+
+            if (_FilterField) {
+              selectionFields.push(_FilterField);
+            }
+          }
+        }
+      });
+    } else if (properties) {
+      properties.forEach(function (property) {
+        var _property$annotations9, _property$annotations10;
+
+        var defaultFilterValue = (_property$annotations9 = property.annotations) === null || _property$annotations9 === void 0 ? void 0 : (_property$annotations10 = _property$annotations9.Common) === null || _property$annotations10 === void 0 ? void 0 : _property$annotations10.FilterDefaultValue;
+        var PropertyPath = property.name;
+
+        if (!(PropertyPath in excludedFilterProperties)) {
+          if (defaultFilterValue && !(PropertyPath in UISelectionFields)) {
+            var _FilterField2 = _getFilterField(filterFields, PropertyPath, converterContext, entityType);
+
+            if (_FilterField2) {
+              selectionFields.push(_FilterField2);
+            }
+          }
+        }
+      });
+    }
+
+    return selectionFields;
+  };
+  /**
+   * Get all Parameter filterFields in case of a parameterized service.
+   * @param {ConverterContext} converterContext
+   * @returns {FilterField[]} An array of parameter filterfields
+   */
+
+
+  function _getParameterFields(converterContext) {
+    var _parameterEntityType$, _parameterEntityType$2;
+
+    var dataModelObjectPath = converterContext.getDataModelObjectPath();
+    var parameterEntityType = dataModelObjectPath.startingEntitySet.entityType;
+    var isParameterized = !!((_parameterEntityType$ = parameterEntityType.annotations) !== null && _parameterEntityType$ !== void 0 && (_parameterEntityType$2 = _parameterEntityType$.Common) !== null && _parameterEntityType$2 !== void 0 && _parameterEntityType$2.ResultContext);
+    var parameterConverterContext = isParameterized && converterContext.getConverterContextFor("/" + dataModelObjectPath.startingEntitySet.name);
+    var parameterFields = parameterConverterContext ? parameterEntityType.entityProperties.map(function (property) {
+      return _getFilterField({}, property.name, parameterConverterContext, parameterEntityType);
+    }) : [];
+    return parameterFields;
+  }
+  /**
+   * Determines if the FilterBar search field is hidden or not.
+   *
+   * @param {TableVisualization[]} listReportTables The list report tables
+   * @param {ConverterContext} converterContext The converter context
+   * @returns {boolean} The information if the FilterBar search field is hidden or not
+   */
+
+
+  var getFilterBarhideBasicSearch = function (listReportTables, converterContext) {
+    if (converterContext.getManifestWrapper().hasMultipleVisualizations() || converterContext.getTemplateType() === TemplateType.AnalyticalListPage) {
+      return true;
+    } // Tries to find a non-analytical table with the main entity set (page entity set) as collection
+    // if at least one table matches these conditions, basic search field must be displayed.
+
+
+    var sContextPath = converterContext.getContextPath();
+    return checkAllTableForEntitySetAreAnalytical(listReportTables, sContextPath);
+  };
+  /**
+   * Retrieves filter fields from the manifest.
+   *
+   * @param entityType The current entityType
+   * @param converterContext The converter context
+   * @returns {Record<string, CustomElementFilterField>} The filter fields defined in the manifest
+   */
+
+
+  _exports.getFilterBarhideBasicSearch = getFilterBarhideBasicSearch;
+
+  var getManifestFilterFields = function (entityType, converterContext) {
+    var fbConfig = converterContext.getManifestWrapper().getFilterConfiguration();
+    var definedFilterFields = (fbConfig === null || fbConfig === void 0 ? void 0 : fbConfig.filterFields) || {};
+
+    var selectionFields = _getSelectionFieldsByPath(entityType, Object.keys(definedFilterFields).map(function (key) {
+      return KeyHelper.getPathFromSelectionFieldKey(key);
+    }), true, converterContext);
+
+    var filterFields = {};
+
+    for (var sKey in definedFilterFields) {
+      var filterField = definedFilterFields[sKey];
+      var propertyName = KeyHelper.getPathFromSelectionFieldKey(sKey);
+      var selectionField = selectionFields[propertyName];
+      var visualFilter = getVisualFilters(entityType, converterContext, sKey, definedFilterFields);
+      filterFields[sKey] = {
+        key: sKey,
+        annotationPath: selectionField === null || selectionField === void 0 ? void 0 : selectionField.annotationPath,
+        conditionPath: (selectionField === null || selectionField === void 0 ? void 0 : selectionField.conditionPath) || propertyName,
+        template: filterField.template,
+        label: filterField.label,
+        position: filterField.position || {
+          placement: Placement.After
+        },
+        availability: filterField.availability || AvailabilityType.Default,
+        settings: filterField.settings,
+        visualFilter: visualFilter
+      };
+    }
+
+    return filterFields;
+  };
+
+  _exports.getManifestFilterFields = getManifestFilterFields;
+
+  var getFilterField = function (propertyPath, converterContext, entityType) {
+    return _getFilterField({}, propertyPath, converterContext, entityType);
+  };
+  /**
+   * Retrieve the configuration for the selection fields that will be used within the filter bar
+   * This configuration takes into account annotation and the selection variants.
+   *
+   * @param {ConverterContext} converterContext
+   * @param {TableVisualization[]} lrTables
+   * @param {string} annotationPath
+   * @returns {FilterSelectionField[]} An array of selection fields
+   */
+
+
+  _exports.getFilterField = getFilterField;
+
+  var getSelectionFields = function (converterContext) {
+    var _entityType$annotatio3, _converterContext$get, _entityType$annotatio4, _entityType$annotatio5;
+
+    var lrTables = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var annotationPath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "";
+    // Fetch all selectionVariants defined in the different visualizations and different views (multi table mode)
+    var selectionVariants = getSelectionVariants(lrTables, converterContext); // create a map of properties to be used in selection variants
+
+    var excludedFilterProperties = getExcludedFilterProperties(selectionVariants);
+    var entityType = converterContext.getEntityType();
+    var filterFacets = (_entityType$annotatio3 = entityType.annotations.UI) === null || _entityType$annotatio3 === void 0 ? void 0 : _entityType$annotatio3.FilterFacets;
+    var filterFacetMap = {};
+    var aFieldGroups = converterContext.getAnnotationsByTerm("UI", "com.sap.vocabularies.UI.v1.FieldGroup");
+
+    if (filterFacets === undefined || filterFacets.length < 0) {
+      for (var i in aFieldGroups) {
+        filterFacetMap = _objectSpread(_objectSpread({}, filterFacetMap), getFieldGroupFilterGroups(aFieldGroups[i]));
+      }
+    } else {
+      filterFacetMap = filterFacets.reduce(function (previousValue, filterFacet) {
+        for (var _i = 0; _i < filterFacet.Target.$target.Data.length; _i++) {
+          var _filterFacet$ID, _filterFacet$Label;
+
+          previousValue[filterFacet.Target.$target.Data[_i].Value.path] = {
+            group: filterFacet === null || filterFacet === void 0 ? void 0 : (_filterFacet$ID = filterFacet.ID) === null || _filterFacet$ID === void 0 ? void 0 : _filterFacet$ID.toString(),
+            groupLabel: filterFacet === null || filterFacet === void 0 ? void 0 : (_filterFacet$Label = filterFacet.Label) === null || _filterFacet$Label === void 0 ? void 0 : _filterFacet$Label.toString()
+          };
+        }
+
+        return previousValue;
+      }, {});
+    }
+
+    var aSelectOptions = [];
+    var selectionVariant = getSelectionVariant(entityType, converterContext);
+
+    if (selectionVariant) {
+      aSelectOptions = selectionVariant.SelectOptions;
+    } // create a map of all potential filter fields based on...
+
+
+    var filterFields = _objectSpread(_objectSpread({}, _getSelectionFields(entityType, "", entityType.entityProperties, false, converterContext)), _getSelectionFieldsByPath(entityType, converterContext.getManifestWrapper().getFilterConfiguration().navigationProperties, false, converterContext)); //Filters which has to be added which is part of SV/Default annotations but not present in the SelectionFields
+
+
+    var annotatedSelectionFields = annotationPath && ((_converterContext$get = converterContext.getEntityTypeAnnotation(annotationPath)) === null || _converterContext$get === void 0 ? void 0 : _converterContext$get.annotation) || ((_entityType$annotatio4 = entityType.annotations) === null || _entityType$annotatio4 === void 0 ? void 0 : (_entityType$annotatio5 = _entityType$annotatio4.UI) === null || _entityType$annotatio5 === void 0 ? void 0 : _entityType$annotatio5.SelectionFields) || [];
+
+    var defaultFilters = _getDefaultFilterFields(filterFields, aSelectOptions, entityType, converterContext, excludedFilterProperties, annotatedSelectionFields);
+
+    var parameterFields = _getParameterFields(converterContext); // finally create final list of filter fields by adding the SelectionFields first (order matters)...
+
+
+    var allFilters = parameterFields.concat((annotatedSelectionFields === null || annotatedSelectionFields === void 0 ? void 0 : annotatedSelectionFields.reduce(function (selectionFields, selectionField) {
+      var propertyPath = selectionField.value;
+
+      if (!(propertyPath in excludedFilterProperties)) {
+        var filterField = _getFilterField(filterFields, propertyPath, converterContext, entityType);
+
+        if (filterField) {
+          filterField.group = "";
+          filterField.groupLabel = "";
+          selectionFields.push(filterField);
+        }
+      }
+
+      return selectionFields;
+    }, [])) || []) // To add the FilterField which is not part of the Selection Fields but the property is mentioned in the Selection Variant
+    .concat(defaultFilters || []) // ...and adding remaining filter fields, that are not used in a SelectionVariant (order doesn't matter)
+    .concat(Object.keys(filterFields).filter(function (propertyPath) {
+      return !(propertyPath in excludedFilterProperties);
+    }).map(function (propertyPath) {
+      return Object.assign(filterFields[propertyPath], filterFacetMap[propertyPath]);
+    }));
+    var sContextPath = converterContext.getContextPath(); //if all tables are analytical tables "aggregatable" properties must be excluded
+
+    if (checkAllTableForEntitySetAreAnalytical(lrTables, sContextPath)) {
+      // Currently all agregates are root entity properties (no properties coming from navigation) and all
+      // tables with same entitySet gets same aggreagte configuration that's why we can use first table into
+      // LR to get aggregates (without currency/unit properties since we expect to be able to filter them).
+      var aggregates = lrTables[0].aggregates;
+
+      if (aggregates) {
+        var aggregatableProperties = Object.keys(aggregates).map(function (aggregateKey) {
+          return aggregates[aggregateKey].relativePath;
+        });
+        allFilters = allFilters.filter(function (filterField) {
+          return aggregatableProperties.indexOf(filterField.key) === -1;
+        });
+      }
+    }
+
+    var selectionFields = insertCustomElements(allFilters, getManifestFilterFields(entityType, converterContext), {
+      "availability": "overwrite",
+      label: "overwrite",
+      position: "overwrite",
+      template: "overwrite",
+      settings: "overwrite",
+      visualFilter: "overwrite"
+    }); // Add caseSensitive property to all selection fields.
+
+    var isCaseSensitive = isFilteringCaseSensitive(converterContext);
+    selectionFields.forEach(function (filterField) {
+      filterField.caseSensitive = isCaseSensitive;
+    });
+    return selectionFields;
+  };
+
+  _exports.getSelectionFields = getSelectionFields;
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["FilterBar.ts"],"names":["getFieldGroupFilterGroups","fieldGroup","filterFacetMap","Data","forEach","dataField","$Type","Value","path","group","fullyQualifiedName","groupLabel","compileBinding","annotationExpression","Label","annotations","Common","qualifier","getExcludedFilterProperties","selectionVariants","reduce","previousValue","selectionVariant","propertyNames","propertyName","checkAllTableForEntitySetAreAnalytical","listReportTables","contextPath","length","every","visualization","enableAnalytics","annotation","collection","getSelectionVariants","lrTableVisualizations","converterContext","selectionVariantPaths","map","tableFilters","control","filters","tableSVConfigs","key","Array","isArray","paths","annotationPath","indexOf","push","selectionVariantConfig","getSelectionVariantConfiguration","svConfigs","concat","_getConditionPath","entityType","propertyPath","parts","split","partialPath","part","shift","property","resolvePath","_type","isCollection","_createFilterSelectionField","fullPropertyPath","includeHidden","undefined","targetType","UI","Hidden","valueOf","targetEntityType","getAnnotationEntityType","KeyHelper","getSelectionFieldKeyFromPath","getAbsoluteAnnotationPath","conditionPath","availability","HiddenFilter","AvailabilityType","Adaptation","label","name","_getSelectionFields","navigationPath","properties","selectionFieldMap","fullPath","selectionField","_getSelectionFieldsByPath","propertyPaths","selectionFields","localSelectionFields","entityProperties","includes","splice","join","_getFilterField","filterFields","filterField","getDiagnostics","addIssue","IssueCategory","Annotation","IssueSeverity","High","IssueType","MISSING_SELECTIONFIELD","Default","isParameter","ResultContext","_getDefaultFilterFields","aSelectOptions","excludedFilterProperties","annotatedSelectionFields","UISelectionFields","SelectionField","value","selectOption","PropertyName","sPropertyPath","FilterField","defaultFilterValue","FilterDefaultValue","PropertyPath","_getParameterFields","dataModelObjectPath","getDataModelObjectPath","parameterEntityType","startingEntitySet","isParameterized","parameterConverterContext","getConverterContextFor","parameterFields","getFilterBarhideBasicSearch","getManifestWrapper","hasMultipleVisualizations","getTemplateType","TemplateType","AnalyticalListPage","sContextPath","getContextPath","getManifestFilterFields","fbConfig","getFilterConfiguration","definedFilterFields","Object","keys","getPathFromSelectionFieldKey","sKey","visualFilter","getVisualFilters","template","position","placement","Placement","After","settings","getFilterField","getSelectionFields","lrTables","getEntityType","filterFacets","FilterFacets","aFieldGroups","getAnnotationsByTerm","i","filterFacet","Target","$target","ID","toString","getSelectionVariant","SelectOptions","navigationProperties","getEntityTypeAnnotation","SelectionFields","defaultFilters","allFilters","filter","assign","aggregates","aggregatableProperties","aggregateKey","relativePath","insertCustomElements","isCaseSensitive","isFilteringCaseSensitive","caseSensitive"],"mappings":"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","sourceRoot":".","sourcesContent":["import {\n\tAvailabilityType,\n\tFilterFieldManifestConfiguration,\n\tFilterManifestConfiguration,\n\tFilterSettings,\n\tTemplateType\n} from \"../../ManifestSettings\";\nimport { EntityType, NavigationProperty, Property } from \"@sap-ux/annotation-converter\";\nimport ConverterContext from \"sap/fe/core/converters/ConverterContext\";\nimport { AnnotationTerm, DataFieldAbstractTypes, DataFieldTypes, ReferenceFacetTypes, UIAnnotationTerms } from \"@sap-ux/vocabularies-types\";\nimport {\n\tgetSelectionVariantConfiguration,\n\tSelectionVariantConfiguration,\n\tTableVisualization,\n\tisFilteringCaseSensitive\n} from \"sap/fe/core/converters/controls/Common/Table\";\nimport { ConfigurableObject, CustomElement, insertCustomElements, Placement } from \"sap/fe/core/converters/helpers/ConfigurableObject\";\nimport { getVisualFilters, VisualFilters } from \"sap/fe/core/converters/controls/ListReport/VisualFilters\";\nimport { SelectOptionType, FieldGroupType, FieldGroup } from \"@sap-ux/vocabularies-types/dist/generated/UI\";\nimport { annotationExpression, compileBinding } from \"sap/fe/core/helpers/BindingExpression\";\nimport { getSelectionVariant } from \"../Common/DataVisualization\";\nimport { KeyHelper } from \"sap/fe/core/converters/helpers/Key\";\nimport { IssueType, IssueSeverity, IssueCategory } from \"sap/fe/core/converters/helpers/IssueManager\";\nimport { PropertyPath } from \"@sap-ux/vocabularies-types/dist/Edm\";\n\nexport type FilterField = ConfigurableObject & {\n\tconditionPath: string;\n\tavailability: AvailabilityType;\n\tannotationPath: string;\n\tlabel?: string;\n\ttemplate?: string;\n\tgroup?: string;\n\tgroupLabel?: string;\n\tsettings?: FilterSettings;\n\tisParameter?: boolean;\n\tvisualFilter?: VisualFilters;\n\tcaseSensitive?: boolean;\n};\n\ntype FilterGroup = {\n\tgroup?: string;\n\tgroupLabel?: string;\n};\n\nexport type CustomElementFilterField = CustomElement<FilterField>;\n\n/**\n * Enter all DataFields of a given FieldGroup into the filterFacetMap.\n *\n * @param {AnnotationTerm<FieldGroupType>} fieldGroup\n * @returns {Record<string, FilterGroup>} The map of facets for the given fieldGroup\n */\nfunction getFieldGroupFilterGroups(fieldGroup: AnnotationTerm<FieldGroupType>): Record<string, FilterGroup> {\n\tconst filterFacetMap: Record<string, FilterGroup> = {};\n\tfieldGroup.Data.forEach((dataField: DataFieldAbstractTypes) => {\n\t\tif (dataField.$Type === \"com.sap.vocabularies.UI.v1.DataField\") {\n\t\t\tfilterFacetMap[dataField.Value.path] = {\n\t\t\t\tgroup: fieldGroup.fullyQualifiedName,\n\t\t\t\tgroupLabel:\n\t\t\t\t\tcompileBinding(\n\t\t\t\t\t\tannotationExpression(fieldGroup.Label || fieldGroup.annotations?.Common?.Label || fieldGroup.qualifier)\n\t\t\t\t\t) || fieldGroup.qualifier\n\t\t\t};\n\t\t}\n\t});\n\treturn filterFacetMap;\n}\n\nfunction getExcludedFilterProperties(selectionVariants: SelectionVariantConfiguration[]): Record<string, boolean> {\n\treturn selectionVariants.reduce((previousValue: Record<string, boolean>, selectionVariant) => {\n\t\tselectionVariant.propertyNames.forEach(propertyName => {\n\t\t\tpreviousValue[propertyName] = true;\n\t\t});\n\t\treturn previousValue;\n\t}, {});\n}\n\n/**\n * Check that all the tables for a dedicated entityset are configured as analytical table.\n * @param {TableVisualization[]} listReportTables List Report tables\n * @param {string} contextPath\n * @returns {boolean} Is FilterBar search field hidden or not\n */\nfunction checkAllTableForEntitySetAreAnalytical(listReportTables: TableVisualization[], contextPath: string | undefined) {\n\tif (contextPath && listReportTables.length > 0) {\n\t\treturn listReportTables.every(visualization => {\n\t\t\treturn visualization.enableAnalytics && contextPath === visualization.annotation.collection;\n\t\t});\n\t}\n\treturn false;\n}\n\nfunction getSelectionVariants(\n\tlrTableVisualizations: TableVisualization[],\n\tconverterContext: ConverterContext\n): SelectionVariantConfiguration[] {\n\tconst selectionVariantPaths: string[] = [];\n\treturn lrTableVisualizations\n\t\t.map(visualization => {\n\t\t\tconst tableFilters = visualization.control.filters;\n\t\t\tconst tableSVConfigs: SelectionVariantConfiguration[] = [];\n\t\t\tfor (const key in tableFilters) {\n\t\t\t\tif (Array.isArray(tableFilters[key].paths)) {\n\t\t\t\t\tconst paths = tableFilters[key].paths;\n\t\t\t\t\tpaths.forEach(path => {\n\t\t\t\t\t\tif (path && path.annotationPath && selectionVariantPaths.indexOf(path.annotationPath) === -1) {\n\t\t\t\t\t\t\tselectionVariantPaths.push(path.annotationPath);\n\t\t\t\t\t\t\tconst selectionVariantConfig = getSelectionVariantConfiguration(path.annotationPath, converterContext);\n\t\t\t\t\t\t\tif (selectionVariantConfig) {\n\t\t\t\t\t\t\t\ttableSVConfigs.push(selectionVariantConfig);\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\treturn tableSVConfigs;\n\t\t})\n\t\t.reduce((svConfigs, selectionVariant) => svConfigs.concat(selectionVariant), []);\n}\n\n/**\n * Returns the condition path required for the condition model. It looks like follow:\n * <1:N-PropertyName>*\\/<1:1-PropertyName>/<PropertyName>.\n *\n * @param entityType The root EntityTy[e\n * @param propertyPath The full path to the target property\n * @returns {string} The formatted condition path\n */\nconst _getConditionPath = function(entityType: EntityType, propertyPath: string): string {\n\tconst parts = propertyPath.split(\"/\");\n\tlet partialPath;\n\tlet key = \"\";\n\twhile (parts.length) {\n\t\tlet part = parts.shift() as string;\n\t\tpartialPath = partialPath ? partialPath + \"/\" + part : part;\n\t\tconst property: Property | NavigationProperty = entityType.resolvePath(partialPath);\n\t\tif (property._type === \"NavigationProperty\" && property.isCollection) {\n\t\t\tpart += \"*\";\n\t\t}\n\t\tkey = key ? key + \"/\" + part : part;\n\t}\n\treturn key;\n};\n\nconst _createFilterSelectionField = function(\n\tentityType: EntityType,\n\tproperty: Property,\n\tfullPropertyPath: string,\n\tincludeHidden: boolean,\n\tconverterContext: ConverterContext\n): FilterField | undefined {\n\t// ignore complex property types and hidden annotated ones\n\tif (\n\t\tproperty !== undefined &&\n\t\tproperty.targetType === undefined &&\n\t\t(includeHidden || property.annotations?.UI?.Hidden?.valueOf() !== true)\n\t) {\n\t\tconst targetEntityType = converterContext.getAnnotationEntityType(property);\n\t\treturn {\n\t\t\tkey: KeyHelper.getSelectionFieldKeyFromPath(fullPropertyPath),\n\t\t\tannotationPath: converterContext.getAbsoluteAnnotationPath(fullPropertyPath),\n\t\t\tconditionPath: _getConditionPath(entityType, fullPropertyPath),\n\t\t\tavailability:\n\t\t\t\tproperty.annotations?.UI?.HiddenFilter?.valueOf() === true ? AvailabilityType.Hidden : AvailabilityType.Adaptation,\n\t\t\tlabel: compileBinding(annotationExpression(property.annotations.Common?.Label?.valueOf() || property.name)),\n\t\t\tgroup: targetEntityType.name,\n\t\t\tgroupLabel: compileBinding(\n\t\t\t\tannotationExpression(targetEntityType?.annotations?.Common?.Label?.valueOf() || targetEntityType.name)\n\t\t\t)\n\t\t};\n\t}\n\treturn undefined;\n};\n\nconst _getSelectionFields = function(\n\tentityType: EntityType,\n\tnavigationPath: string,\n\tproperties: Array<Property> | undefined,\n\tincludeHidden: boolean,\n\tconverterContext: ConverterContext\n): Record<string, FilterField> {\n\tconst selectionFieldMap: Record<string, FilterField> = {};\n\tif (properties) {\n\t\tproperties.forEach((property: Property) => {\n\t\t\tconst propertyPath: string = property.name;\n\t\t\tconst fullPath: string = (navigationPath ? navigationPath + \"/\" : \"\") + propertyPath;\n\t\t\tconst selectionField = _createFilterSelectionField(entityType, property, fullPath, includeHidden, converterContext);\n\t\t\tif (selectionField) {\n\t\t\t\tselectionFieldMap[fullPath] = selectionField;\n\t\t\t}\n\t\t});\n\t}\n\treturn selectionFieldMap;\n};\n\nconst _getSelectionFieldsByPath = function(\n\tentityType: EntityType,\n\tpropertyPaths: Array<string> | undefined,\n\tincludeHidden: boolean,\n\tconverterContext: ConverterContext\n): Record<string, FilterField> {\n\tlet selectionFields: Record<string, FilterField> = {};\n\tif (propertyPaths) {\n\t\tpropertyPaths.forEach((propertyPath: string) => {\n\t\t\tlet localSelectionFields: Record<string, FilterField>;\n\n\t\t\tconst property: Property | NavigationProperty = entityType.resolvePath(propertyPath);\n\t\t\tif (property === undefined) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (property._type === \"NavigationProperty\") {\n\t\t\t\t// handle navigation properties\n\t\t\t\tlocalSelectionFields = _getSelectionFields(\n\t\t\t\t\tentityType,\n\t\t\t\t\tpropertyPath,\n\t\t\t\t\tproperty.targetType.entityProperties,\n\t\t\t\t\tincludeHidden,\n\t\t\t\t\tconverterContext\n\t\t\t\t);\n\t\t\t} else if (property.targetType !== undefined) {\n\t\t\t\t// handle ComplexType properties\n\t\t\t\tlocalSelectionFields = _getSelectionFields(\n\t\t\t\t\tentityType,\n\t\t\t\t\tpropertyPath,\n\t\t\t\t\tproperty.targetType.properties,\n\t\t\t\t\tincludeHidden,\n\t\t\t\t\tconverterContext\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tconst navigationPath = propertyPath.includes(\"/\")\n\t\t\t\t\t? propertyPath\n\t\t\t\t\t\t\t.split(\"/\")\n\t\t\t\t\t\t\t.splice(0, 1)\n\t\t\t\t\t\t\t.join(\"/\")\n\t\t\t\t\t: \"\";\n\t\t\t\tlocalSelectionFields = _getSelectionFields(entityType, navigationPath, [property], includeHidden, converterContext);\n\t\t\t}\n\n\t\t\tselectionFields = {\n\t\t\t\t...selectionFields,\n\t\t\t\t...localSelectionFields\n\t\t\t};\n\t\t});\n\t}\n\treturn selectionFields;\n};\n\nconst _getFilterField = function(\n\tfilterFields: Record<string, FilterField>,\n\tpropertyPath: string,\n\tconverterContext: ConverterContext,\n\tentityType: EntityType\n): FilterField | undefined {\n\tlet filterField: FilterField | undefined = filterFields[propertyPath];\n\tif (filterField) {\n\t\tdelete filterFields[propertyPath];\n\t} else {\n\t\tfilterField = _createFilterSelectionField(entityType, entityType.resolvePath(propertyPath), propertyPath, true, converterContext);\n\t}\n\tif (!filterField) {\n\t\tconverterContext.getDiagnostics().addIssue(IssueCategory.Annotation, IssueSeverity.High, IssueType.MISSING_SELECTIONFIELD);\n\t}\n\t// defined SelectionFields are available by default\n\tif (filterField) {\n\t\tfilterField.availability = AvailabilityType.Default;\n\t\tfilterField.isParameter = !!entityType.annotations?.Common?.ResultContext;\n\t}\n\treturn filterField;\n};\n\nconst _getDefaultFilterFields = function(\n\tfilterFields: Record<string, FilterField>,\n\taSelectOptions: any[],\n\tentityType: EntityType,\n\tconverterContext: ConverterContext,\n\texcludedFilterProperties: Record<string, boolean>,\n\tannotatedSelectionFields: PropertyPath[]\n): FilterField[] {\n\tconst selectionFields: FilterField[] = [];\n\tconst UISelectionFields: any = {};\n\tconst properties = entityType.entityProperties;\n\t// Using entityType instead of entitySet\n\tannotatedSelectionFields?.forEach(SelectionField => {\n\t\tUISelectionFields[SelectionField.value] = true;\n\t});\n\tif (aSelectOptions && aSelectOptions.length > 0) {\n\t\taSelectOptions?.forEach((selectOption: SelectOptionType) => {\n\t\t\tconst propertyName: any = selectOption.PropertyName;\n\t\t\tconst sPropertyPath: string = propertyName.value;\n\t\t\tconst UISelectionFields: any = {};\n\t\t\tannotatedSelectionFields?.forEach(SelectionField => {\n\t\t\t\tUISelectionFields[SelectionField.value] = true;\n\t\t\t});\n\t\t\tif (!(sPropertyPath in excludedFilterProperties)) {\n\t\t\t\tif (!(sPropertyPath in UISelectionFields)) {\n\t\t\t\t\tconst FilterField: FilterField | undefined = _getFilterField(filterFields, sPropertyPath, converterContext, entityType);\n\t\t\t\t\tif (FilterField) {\n\t\t\t\t\t\tselectionFields.push(FilterField);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t} else if (properties) {\n\t\tproperties.forEach((property: Property) => {\n\t\t\tconst defaultFilterValue = property.annotations?.Common?.FilterDefaultValue;\n\t\t\tconst PropertyPath = property.name;\n\t\t\tif (!(PropertyPath in excludedFilterProperties)) {\n\t\t\t\tif (defaultFilterValue && !(PropertyPath in UISelectionFields)) {\n\t\t\t\t\tconst FilterField: FilterField | undefined = _getFilterField(filterFields, PropertyPath, converterContext, entityType);\n\t\t\t\t\tif (FilterField) {\n\t\t\t\t\t\tselectionFields.push(FilterField);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n\treturn selectionFields;\n};\n\n/**\n * Get all Parameter filterFields in case of a parameterized service.\n * @param {ConverterContext} converterContext\n * @returns {FilterField[]} An array of parameter filterfields\n */\nfunction _getParameterFields(converterContext: ConverterContext): FilterField[] {\n\tconst dataModelObjectPath = converterContext.getDataModelObjectPath();\n\tconst parameterEntityType = dataModelObjectPath.startingEntitySet.entityType;\n\tconst isParameterized = !!parameterEntityType.annotations?.Common?.ResultContext;\n\tconst parameterConverterContext =\n\t\tisParameterized && converterContext.getConverterContextFor(\"/\" + dataModelObjectPath.startingEntitySet.name);\n\n\tconst parameterFields = (parameterConverterContext\n\t\t? parameterEntityType.entityProperties.map(function(property) {\n\t\t\t\treturn _getFilterField({} as Record<string, FilterField>, property.name, parameterConverterContext, parameterEntityType);\n\t\t  })\n\t\t: []) as FilterField[];\n\n\treturn parameterFields;\n}\n\n/**\n * Determines if the FilterBar search field is hidden or not.\n *\n * @param {TableVisualization[]} listReportTables The list report tables\n * @param {ConverterContext} converterContext The converter context\n * @returns {boolean} The information if the FilterBar search field is hidden or not\n */\nexport const getFilterBarhideBasicSearch = function(listReportTables: TableVisualization[], converterContext: ConverterContext): boolean {\n\tif (\n\t\tconverterContext.getManifestWrapper().hasMultipleVisualizations() ||\n\t\tconverterContext.getTemplateType() === TemplateType.AnalyticalListPage\n\t) {\n\t\treturn true;\n\t}\n\t// Tries to find a non-analytical table with the main entity set (page entity set) as collection\n\t// if at least one table matches these conditions, basic search field must be displayed.\n\tconst sContextPath = converterContext.getContextPath();\n\treturn checkAllTableForEntitySetAreAnalytical(listReportTables, sContextPath);\n};\n\n/**\n * Retrieves filter fields from the manifest.\n *\n * @param entityType The current entityType\n * @param converterContext The converter context\n * @returns {Record<string, CustomElementFilterField>} The filter fields defined in the manifest\n */\nexport const getManifestFilterFields = function(\n\tentityType: EntityType,\n\tconverterContext: ConverterContext\n): Record<string, CustomElementFilterField> {\n\tconst fbConfig: FilterManifestConfiguration = converterContext.getManifestWrapper().getFilterConfiguration();\n\tconst definedFilterFields: Record<string, FilterFieldManifestConfiguration> = fbConfig?.filterFields || {};\n\tconst selectionFields: Record<string, FilterField> = _getSelectionFieldsByPath(\n\t\tentityType,\n\t\tObject.keys(definedFilterFields).map(key => KeyHelper.getPathFromSelectionFieldKey(key)),\n\t\ttrue,\n\t\tconverterContext\n\t);\n\tconst filterFields: Record<string, CustomElementFilterField> = {};\n\n\tfor (const sKey in definedFilterFields) {\n\t\tconst filterField = definedFilterFields[sKey];\n\t\tconst propertyName = KeyHelper.getPathFromSelectionFieldKey(sKey);\n\t\tconst selectionField = selectionFields[propertyName];\n\t\tconst visualFilter = getVisualFilters(entityType, converterContext, sKey, definedFilterFields);\n\t\tfilterFields[sKey] = {\n\t\t\tkey: sKey,\n\t\t\tannotationPath: selectionField?.annotationPath,\n\t\t\tconditionPath: selectionField?.conditionPath || propertyName,\n\t\t\ttemplate: filterField.template,\n\t\t\tlabel: filterField.label,\n\t\t\tposition: filterField.position || { placement: Placement.After },\n\t\t\tavailability: filterField.availability || AvailabilityType.Default,\n\t\t\tsettings: filterField.settings,\n\t\t\tvisualFilter: visualFilter\n\t\t};\n\t}\n\treturn filterFields;\n};\n\nexport const getFilterField = function(propertyPath: string, converterContext: ConverterContext, entityType: EntityType) {\n\treturn _getFilterField({}, propertyPath, converterContext, entityType);\n};\n\n/**\n * Retrieve the configuration for the selection fields that will be used within the filter bar\n * This configuration takes into account annotation and the selection variants.\n *\n * @param {ConverterContext} converterContext\n * @param {TableVisualization[]} lrTables\n * @param {string} annotationPath\n * @returns {FilterSelectionField[]} An array of selection fields\n */\nexport const getSelectionFields = function(\n\tconverterContext: ConverterContext,\n\tlrTables: TableVisualization[] = [],\n\tannotationPath: string = \"\"\n): FilterField[] {\n\t// Fetch all selectionVariants defined in the different visualizations and different views (multi table mode)\n\tconst selectionVariants: SelectionVariantConfiguration[] = getSelectionVariants(lrTables, converterContext);\n\n\t// create a map of properties to be used in selection variants\n\tconst excludedFilterProperties: Record<string, boolean> = getExcludedFilterProperties(selectionVariants);\n\tconst entityType = converterContext.getEntityType();\n\tconst filterFacets = entityType.annotations.UI?.FilterFacets;\n\tlet filterFacetMap: Record<string, FilterGroup> = {};\n\n\tconst aFieldGroups = converterContext.getAnnotationsByTerm(\"UI\", UIAnnotationTerms.FieldGroup);\n\n\tif (filterFacets === undefined || filterFacets.length < 0) {\n\t\tfor (const i in aFieldGroups) {\n\t\t\tfilterFacetMap = {\n\t\t\t\t...filterFacetMap,\n\t\t\t\t...getFieldGroupFilterGroups(aFieldGroups[i] as AnnotationTerm<FieldGroupType>)\n\t\t\t};\n\t\t}\n\t} else {\n\t\tfilterFacetMap = filterFacets.reduce((previousValue: Record<string, FilterGroup>, filterFacet: ReferenceFacetTypes) => {\n\t\t\tfor (let i = 0; i < (filterFacet.Target.$target as FieldGroup).Data.length; i++) {\n\t\t\t\tpreviousValue[((filterFacet.Target.$target as FieldGroup).Data[i] as DataFieldTypes).Value.path] = {\n\t\t\t\t\tgroup: filterFacet?.ID?.toString(),\n\t\t\t\t\tgroupLabel: filterFacet?.Label?.toString()\n\t\t\t\t};\n\t\t\t}\n\t\t\treturn previousValue;\n\t\t}, {});\n\t}\n\n\tlet aSelectOptions: any[] = [];\n\tconst selectionVariant = getSelectionVariant(entityType, converterContext);\n\tif (selectionVariant) {\n\t\taSelectOptions = selectionVariant.SelectOptions;\n\t}\n\n\t// create a map of all potential filter fields based on...\n\tconst filterFields: Record<string, FilterField> = {\n\t\t// ...non hidden properties of the entity\n\t\t..._getSelectionFields(entityType, \"\", entityType.entityProperties, false, converterContext),\n\t\t// ...additional manifest defined navigation properties\n\t\t..._getSelectionFieldsByPath(\n\t\t\tentityType,\n\t\t\tconverterContext.getManifestWrapper().getFilterConfiguration().navigationProperties,\n\t\t\tfalse,\n\t\t\tconverterContext\n\t\t)\n\t};\n\n\t//Filters which has to be added which is part of SV/Default annotations but not present in the SelectionFields\n\tconst annotatedSelectionFields = ((annotationPath && converterContext.getEntityTypeAnnotation(annotationPath)?.annotation) ||\n\t\tentityType.annotations?.UI?.SelectionFields ||\n\t\t[]) as PropertyPath[];\n\tconst defaultFilters = _getDefaultFilterFields(\n\t\tfilterFields,\n\t\taSelectOptions,\n\t\tentityType,\n\t\tconverterContext,\n\t\texcludedFilterProperties,\n\t\tannotatedSelectionFields\n\t);\n\tconst parameterFields = _getParameterFields(converterContext);\n\n\t// finally create final list of filter fields by adding the SelectionFields first (order matters)...\n\tlet allFilters = parameterFields\n\t\t.concat(\n\t\t\tannotatedSelectionFields?.reduce((selectionFields: FilterField[], selectionField) => {\n\t\t\t\tconst propertyPath = selectionField.value;\n\t\t\t\tif (!(propertyPath in excludedFilterProperties)) {\n\t\t\t\t\tconst filterField: FilterField | undefined = _getFilterField(filterFields, propertyPath, converterContext, entityType);\n\t\t\t\t\tif (filterField) {\n\t\t\t\t\t\tfilterField.group = \"\";\n\t\t\t\t\t\tfilterField.groupLabel = \"\";\n\t\t\t\t\t\tselectionFields.push(filterField);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn selectionFields;\n\t\t\t}, []) || []\n\t\t)\n\t\t// To add the FilterField which is not part of the Selection Fields but the property is mentioned in the Selection Variant\n\t\t.concat(defaultFilters || [])\n\t\t// ...and adding remaining filter fields, that are not used in a SelectionVariant (order doesn't matter)\n\t\t.concat(\n\t\t\tObject.keys(filterFields)\n\t\t\t\t.filter(propertyPath => !(propertyPath in excludedFilterProperties))\n\t\t\t\t.map(propertyPath => {\n\t\t\t\t\treturn Object.assign(filterFields[propertyPath], filterFacetMap[propertyPath]);\n\t\t\t\t})\n\t\t);\n\tconst sContextPath = converterContext.getContextPath();\n\n\t//if all tables are analytical tables \"aggregatable\" properties must be excluded\n\tif (checkAllTableForEntitySetAreAnalytical(lrTables, sContextPath)) {\n\t\t// Currently all agregates are root entity properties (no properties coming from navigation) and all\n\t\t// tables with same entitySet gets same aggreagte configuration that's why we can use first table into\n\t\t// LR to get aggregates (without currency/unit properties since we expect to be able to filter them).\n\t\tconst aggregates = lrTables[0].aggregates;\n\t\tif (aggregates) {\n\t\t\tconst aggregatableProperties: string[] = Object.keys(aggregates).map(aggregateKey => aggregates[aggregateKey].relativePath);\n\t\t\tallFilters = allFilters.filter(filterField => {\n\t\t\t\treturn aggregatableProperties.indexOf(filterField.key) === -1;\n\t\t\t});\n\t\t}\n\t}\n\n\tconst selectionFields = insertCustomElements(allFilters, getManifestFilterFields(entityType, converterContext), {\n\t\t\"availability\": \"overwrite\",\n\t\tlabel: \"overwrite\",\n\t\tposition: \"overwrite\",\n\t\ttemplate: \"overwrite\",\n\t\tsettings: \"overwrite\",\n\t\tvisualFilter: \"overwrite\"\n\t});\n\n\t// Add caseSensitive property to all selection fields.\n\tconst isCaseSensitive = isFilteringCaseSensitive(converterContext);\n\tselectionFields.forEach(filterField => {\n\t\tfilterField.caseSensitive = isCaseSensitive;\n\t});\n\n\treturn selectionFields;\n};\n"]}