@sapui5/sap.fe.macros 1.140.0 → 1.141.0

package/src/sap/fe/macros/ai/EasyFilterBar.tsx

@@ -1,8 +1,11 @@
-import type { Property } from "@sap-ux/vocabularies-types";
+import type { ComplexType, EntitySet, EntityType, NavigationProperty, Property, TypeDefinition } from "@sap-ux/vocabularies-types";
 import Log from "sap/base/Log";
+import Localization from "sap/base/i18n/Localization";
+import { isConstant } from "sap/fe/base/BindingToolkit";
 import type { EnhanceWithUI5 } from "sap/fe/base/ClassSupport";
 import { aggregation, association, defineUI5Class, implementInterface, property, type PropertiesOf } from "sap/fe/base/ClassSupport";
 import type {
+	CodeListType,
 	EasyFilterBarContainer$ShowValueHelpEvent,
 	EasyFilterPropertyMetadata,
 	TokenDefinition,
@@ -15,10 +18,11 @@ import BuildingBlock from "sap/fe/core/buildingBlocks/BuildingBlock";
 import BusyLocker from "sap/fe/core/controllerextensions/BusyLocker";
 import type { ControlState, NavigationParameter } from "sap/fe/core/controllerextensions/ViewState";
 import type IViewStateContributor from "sap/fe/core/controllerextensions/viewState/IViewStateContributor";
-import type { FilterField } from "sap/fe/core/definition/FEDefinition";
+import { type FilterField } from "sap/fe/core/definition/FEDefinition";
 import type MetaPath from "sap/fe/core/helpers/MetaPath";
 import ModelHelper from "sap/fe/core/helpers/ModelHelper";
-import { isPathAnnotationExpression } from "sap/fe/core/helpers/TypeGuards";
+import { isComplexType, isEntityType, isNavigationProperty, isPathAnnotationExpression, isProperty } from "sap/fe/core/helpers/TypeGuards";
+import { isPathFilterable } from "sap/fe/core/templating/DataModelPathHelper";
 import { hasValueHelpWithFixedValues } from "sap/fe/core/templating/PropertyHelper";
 import {
 	generateSelectParameter,
@@ -146,11 +150,9 @@ export default class EasyFilterBar extends BuildingBlock implements IViewStateCo
 		this.content.filterBarMetadata = this.filterBarMetadata;
 	}
 
-	private getUnitForFilterField(field: FilterField, allFilterFields: FilterField[]): string | undefined {
-		const propertyObject = field.getTarget();
-		const unitAnnotation = propertyObject.annotations.Measures?.ISOCurrency ?? propertyObject.annotations.Measures?.Unit;
-		const unitProperty = isPathAnnotationExpression(unitAnnotation) ? unitAnnotation.$target : undefined;
-		return allFilterFields.find((f) => f.getTarget() === unitProperty)?.annotationPath;
+	private getUnitForProperty(prop: Property, basePath: string): string | undefined {
+		const unitAnnotation = prop.annotations.Measures?.ISOCurrency ?? prop.annotations.Measures?.Unit;
+		return isPathAnnotationExpression(unitAnnotation) ? `${basePath}/${unitAnnotation.path}` : undefined;
 	}
 
 	private getDefaultValueForFilterField(
@@ -196,9 +198,9 @@ export default class EasyFilterBar extends BuildingBlock implements IViewStateCo
 		};
 	}
 
-	private getTokenType(prop: Property): TokenType {
+	private getTokenType(prop: Property, filterRestriction: string): TokenType {
 		if (hasValueHelpWithFixedValues(prop)) {
-			return "MenuWithCheckBox";
+			return filterRestriction === "SingleValue" ? "MenuWithSingleSelect" : "MenuWithCheckBox";
 		}
 		switch (prop.type) {
 			case "Edm.Date":
@@ -210,7 +212,44 @@ export default class EasyFilterBar extends BuildingBlock implements IViewStateCo
 		}
 	}
 
+	private getLabel(element: Property | NavigationProperty | EntityType | ComplexType): string | undefined {
+		const label = element.annotations.Common?.Label?.toString();
+		const headerInfoTypeName = isEntityType(element) ? (element.annotations.UI?.HeaderInfo?.TypeName?.valueOf() as string) : undefined;
+		const result = headerInfoTypeName || label;
+
+		if (this.isComplexProperty(element) || isNavigationProperty(element)) {
+			return result || this.getLabel(element.targetType);
+		}
+
+		return result;
+	}
+
+	private isScalarProperty(element: unknown): element is Property & { targetType?: TypeDefinition } {
+		return isProperty(element) && !isComplexType(element.targetType);
+	}
+
+	private isComplexProperty(element: unknown): element is Property & { targetType: ComplexType } {
+		return isProperty(element) && isComplexType(element.targetType);
+	}
+
 	prepareFilterBarMetadata(): FieldMetadata[] {
+		/*
+		 * 1. INITIALIZATION:
+		 *    - Queue all root entity properties and navigation properties for traversal
+		 *    - Initialize result array and elimination set for Common.Text targets
+		 *
+		 * 2. BREADTH-FIRST TRAVERSAL:
+		 *    For each path in queue:
+		 *    - Skip UI.Hidden properties
+		 *    - Scalar properties: Generate metadata, track Common.Text targets for elimination
+		 *    - Complex properties: Add child properties to queue
+		 *    - Navigation properties: Add target EntityType properties to queue
+		 *      (Collections only if explicit filter fields exist, respect depth limits)
+		 *
+		 * 3. POST-PROCESSING:
+		 *    - Add $editState filter for draft-enabled entities
+		 *    - Remove properties marked for elimination (except explicit filter fields)
+		 */
 		const owner = this._getOwner()!;
 		const definitionForPage = owner.preprocessorContext?.getDefinitionForPage();
 
@@ -219,42 +258,155 @@ export default class EasyFilterBar extends BuildingBlock implements IViewStateCo
 		}
 
 		const filterBarDef = definitionForPage.getFilterBarDefinition({});
+		const metaPath = definitionForPage.getMetaPath();
+		const entitySet = metaPath.getClosestEntitySet() as EntitySet;
+
+		let filterExpressionRestrictions = entitySet.annotations.Capabilities?.FilterRestrictions?.FilterExpressionRestrictions ?? [];
+
+		// TODO: Maybe we can simplify this by using restrictions on the main entity set only
+		for (const navigationProperty in entitySet.navigationPropertyBinding) {
+			if (entitySet.navigationPropertyBinding[navigationProperty]?._type === "EntitySet") {
+				// FIXME: optional chaining should not be needed here -> root cause fix pending
+				const navigationPropertyEntitySet = entitySet.navigationPropertyBinding[navigationProperty] as EntitySet;
+				const navPropertyFilterExpressionRestrictions =
+					navigationPropertyEntitySet.annotations.Capabilities?.FilterRestrictions?.FilterExpressionRestrictions ?? [];
+
+				const currentFilterRestrictions = [...filterExpressionRestrictions];
+				filterExpressionRestrictions = [
+					...filterExpressionRestrictions,
+					...navPropertyFilterExpressionRestrictions.filter((restriction) => !currentFilterRestrictions.includes(restriction))
+				];
+			}
+		}
+
 		const metaModel = owner.preprocessorContext?.models.metaModel as ODataMetaModel;
 
+		const getCodeList = (lastPathSegment: Property, propertyPath: string): CodeList | (() => Promise<CodeList>) | undefined =>
+			hasValueHelpWithFixedValues(lastPathSegment)
+				? async (): Promise<CodeList> => this.getCodeListForProperty(propertyPath)
+				: undefined;
+
+		const filterFields = filterBarDef
+			.getFilterFields()
+			.filter((field: FilterField) => !field.getTarget()?.annotations?.UI?.HiddenFilter?.valueOf());
+
 		const startupParameters = owner.getAppComponent().getComponentData()?.startupParameters ?? {};
 
-		const filterFields = filterBarDef.getFilterFields();
-		const nonHiddenFilterFields = filterFields.filter((field: FilterField) => {
-			return !field.getTarget()?.annotations?.UI?.HiddenFilter?.valueOf();
-		});
+		const maxDepth = 1; // Maximum depth for navigation properties
+
+		// Initialize traversal queue with all entity properties and navigation properties.
+		// Each path to traverse is a list of segments (e.g. [navProp1, complexProp1, complexProp2, scalarProp])
+		const pathsToExplore: (Property | NavigationProperty)[][] = [
+			...entitySet.entityType.entityProperties,
+			...entitySet.entityType.navigationProperties
+		].map((element) => [element]);
 
-		const result = nonHiddenFilterFields.map((field: FilterField): FieldMetadata => {
-			const propertyObject = field.getTarget();
-			let codeList: CodeList | (() => Promise<CodeList>) | undefined;
-			if (hasValueHelpWithFixedValues(propertyObject)) {
-				codeList = async (): Promise<CodeList> => this.getCodeListForProperty(field.annotationPath!);
+		// Resulting metadata array
+		const result: EasyFilterPropertyMetadata[] = [];
+
+		// Set of property paths to be eliminated from the filter bar metadata
+		const pathsToEliminate = new Set<string>();
+
+		const getPathLabel = (path: (Property | NavigationProperty)[]): string => {
+			const pathLabels = path.map((e) => this.getLabel(e) || `[${e.name}]`);
+			return Localization.getRTL() ? pathLabels.slice().reverse().join(" - ") : pathLabels.join(" - ");
+		};
+
+		while (pathsToExplore.length > 0) {
+			const currentPath = pathsToExplore.shift()!;
+
+			const navigationDepth = currentPath.filter(isNavigationProperty).length;
+
+			const lastPathSegment = currentPath[currentPath.length - 1];
+
+			if (lastPathSegment.annotations.UI?.Hidden?.valueOf() === true) {
+				continue;
 			}
 
-			return {
-				name: field.annotationPath!,
-				label: field.label,
-				dataType: propertyObject.type,
-				required: field.required ?? false,
-				defaultValue: this.getDefaultValueForFilterField(field, startupParameters),
-				filterable: true,
-				codeList: codeList,
-				type: this.getTokenType(propertyObject) as Exclude<TokenType, "ValueHelp">,
-				unit: this.getUnitForFilterField(field, filterFields),
-				maxLength: propertyObject.maxLength
-			};
-		});
+			const pathString = [`/${entitySet.name}`, ...currentPath.slice(0, -1).map((e) => e.name)].reduce(
+				(acc, curr) => `${acc}/${curr}`
+			);
+			const propertyPath = `${pathString}/${lastPathSegment.name}`;
+
+			if (this.isScalarProperty(lastPathSegment)) {
+				// Check for Common.Text annotation and record the annotation target path for elimination
+				const textAnnotation = lastPathSegment.annotations.Common?.Text;
+				if (isPathAnnotationExpression(textAnnotation)) {
+					// Construct the full path to the target property
+					pathsToEliminate.add(`${pathString}/${textAnnotation.path}`);
+				}
+
+				// Scalar property: create metadata for the property
+				const filterField = filterFields.find((field) => field.getTarget() === lastPathSegment);
+				const filterRestriction = filterExpressionRestrictions.find(
+					(expression) => expression.Property?.$target === lastPathSegment
+				);
+				const filterable = isPathFilterable(this.getDataModelObjectPath(propertyPath));
+				const filterableExpression = isConstant(filterable) ? filterable.value : true;
+				const filterRestrictionExpression = filterRestriction?.AllowedExpressions as
+					| EasyFilterPropertyMetadata["filterRestriction"]
+					| undefined;
+				const codeList = getCodeList(lastPathSegment, propertyPath);
+				const metadata: EasyFilterPropertyMetadata = {
+					name: propertyPath,
+					label: getPathLabel(currentPath),
+					dataType: lastPathSegment.type,
+					required: filterField?.required,
+					defaultValue: filterField ? this.getDefaultValueForFilterField(filterField, startupParameters) : undefined,
+					filterable: filterField ? filterableExpression : undefined,
+					hiddenFilter: !filterField,
+					filterRestriction: filterField ? filterRestrictionExpression : undefined,
+					codeList,
+					type: this.getTokenType(
+						lastPathSegment,
+						filterRestriction?.AllowedExpressions?.toString() || "MultiRangeOrSearchExpression"
+					) as Exclude<TokenType, "ValueHelp">,
+					unit: this.getUnitForProperty(lastPathSegment, pathString)
+				};
+				result.push(metadata);
+			} else if (this.isComplexProperty(lastPathSegment)) {
+				// Complex property: add all properties and navigation properties of the complex type
+				lastPathSegment.targetType.properties.forEach((child) => {
+					pathsToExplore.push([...currentPath, child]);
+				});
+
+				// only traverse navigation properties if we are not at the maximum depth
+				if (navigationDepth < maxDepth) {
+					lastPathSegment.targetType.navigationProperties.forEach((child) => {
+						pathsToExplore.push([...currentPath, child]);
+					});
+				}
+			} else if (isNavigationProperty(lastPathSegment)) {
+				// add 1:n navigation properties only if there are filter fields for at least one of the target properties
+				if (lastPathSegment.isCollection && !filterFields.some((field) => field.annotationPath?.startsWith(propertyPath))) {
+					continue;
+				}
+
+				lastPathSegment.targetType.entityProperties.forEach((child) => {
+					pathsToExplore.push([...currentPath, child]);
+				});
+
+				// only traverse navigation properties if we are not at the maximum depth
+				if (navigationDepth < maxDepth) {
+					lastPathSegment.targetType.navigationProperties.forEach((child) => {
+						pathsToExplore.push([...currentPath, child]);
+					});
+				}
+			}
+		}
 
 		// [Editing Status]
 		if (ModelHelper.isMetaPathDraftSupported(definitionForPage.getMetaPath() as unknown as MetaPath<unknown>)) {
 			result.push(this.getEditStateFilterMetadata(metaModel));
 		}
 
-		return result;
+		// Remove properties marked for elimination (unless they are filter fields)
+		return result.filter((metadata) => {
+			return (
+				!metadata.hiddenFilter || // Keep if explicit filter field
+				!pathsToEliminate.has(metadata.name) // Keep if path not marked for elimination
+			);
+		});
 	}
 
 	async getCodeListForProperty(propertyPath: string): Promise<CodeList> {
@@ -283,37 +435,62 @@ export default class EasyFilterBar extends BuildingBlock implements IViewStateCo
 		fieldName: string,
 		values: TokenSelectedValuesDefinition[]
 	): Promise<ValueHelpSelectedValuesDefinition[]> {
-		let filteredValues = values;
 		const field = this.filterBarMetadata.find(({ name }) => name === fieldName);
-		if (field) {
-			const maxLength = field.maxLength;
-
-			if (maxLength !== undefined) {
-				filteredValues = values
-					.map((token) => {
-						const filtered = token.selectedValues.filter((val) => typeof val !== "string" || val.length <= maxLength);
-						return filtered.length > 0 ? { ...token, selectedValues: filtered } : undefined;
-					})
-					.filter(Boolean) as TokenSelectedValuesDefinition[];
-				if (filteredValues.length === 0) {
-					return [];
-				}
-			}
-			const valueList = await this.getValueList(field.name);
+		let result: ValueHelpSelectedValuesDefinition[];
 
-			if (valueList && ValueListHelper.isValueListSearchable(field.name, valueList)) {
-				const resolvedTokenValues = await Promise.all(filteredValues.map(async (value) => resolveTokenValue(valueList, value)));
-				return resolvedTokenValues.flat();
-			}
+		if (!field) {
+			// return original values converted to the expected format if no field is defined
+			return unresolvedResult(values);
 		}
+		const valueList = await this.getValueList(field.name);
 
-		// return original values converted to the expected format
-		return unresolvedResult(filteredValues);
+		if (valueList && ValueListHelper.isValueListSearchable(field.name, valueList)) {
+			const resolvedTokenValues = await Promise.all(values.map(async (value) => resolveTokenValue(valueList, value)));
+			result = resolvedTokenValues.flat();
+		} else {
+			result = unresolvedResult(values);
+		}
+
+		// Apply maxLength filtering if defined
+		if (field.maxLength !== undefined) {
+			const filteredTokens = result
+				.map((token) => {
+					if (token.operator === FilterOperator.BT || token.operator === FilterOperator.NB) {
+						// Handle between operators - selectedValues is ValueHelpBetweenSelectedValues
+						const [a, b] = token.selectedValues;
+
+						// Check if both values exceed maxLength
+						if (String(a.value).length <= field.maxLength! && String(b.value).length <= field.maxLength!) {
+							return token; // Keep the token if both values are within limit
+						} else {
+							return null; // Remove the token if either value exceeds limit
+						}
+					} else {
+						// Handle other operators - selectedValues is CodeListType[]
+						const filtered: CodeListType[] = token.selectedValues.filter(
+							(selectedValue) => String(selectedValue.value).length <= field.maxLength!
+						);
+
+						// Only return the token if there are remaining values after filtering
+						if (filtered.length > 0) {
+							return { ...token, selectedValues: filtered };
+						} else {
+							return null; // Remove the token if no values remain
+						}
+					}
+				})
+				.filter((token): token is ValueHelpSelectedValuesDefinition => token !== null);
+
+			return filteredTokens;
+		}
+
+		// if no maxLength is defined, return unfiltered result
+		return result;
 	}
 
-	async getValueList(propertyPath: string): Promise<ValueListInfo | undefined> {
+	async getValueList(fieldName: string): Promise<ValueListInfo | undefined> {
 		const metaModel = this.getMetaModel()!;
-		const valueLists = await ValueListHelper.getValueListInfo(undefined, propertyPath, undefined, metaModel);
+		const valueLists = await ValueListHelper.getValueListInfo(undefined, fieldName, undefined, metaModel);
 		return valueLists[0];
 	}
 

package/src/sap/fe/macros/ai/EasyFilterDataFetcher.js

@@ -45,7 +45,13 @@ sap.ui.define(["sap/fe/core/CommonUtils", "sap/fe/core/converters/MetaModelConve
     const path = `/${valueList.valueListInfo.CollectionPath}`;
     const $select = generateSelectParameter(valueList);
     let $search = CommonUtils.normalizeSearchTerm(valueToMatch instanceof Date ? valueToMatch.toISOString() : valueToMatch.toString());
-    const keyPropertyFilter = getKeyPropertyFilter(valueList, keyProperty, operator, valueToMatch);
+
+    // Handle negation operators (NE, NotContains, NotStartsWith, NotEndsWith)
+    // Strategy: Query for positive case, then apply negation client-side
+    const isNegation = isNegationOperator(operator);
+    // "cleaned" operator for possible negation operators
+    const cleanedOperator = isNegation ? getPositiveOperator(operator) : operator;
+    const keyPropertyFilter = getKeyPropertyFilter(valueList, keyProperty, cleanedOperator, valueToMatch);
 
     // Check if the query exceeds the maximum length of the key property
     const characterLimitOverflow = !$search || $search.length > (keyProperty.maxLength ?? $search.length);
@@ -67,7 +73,7 @@ sap.ui.define(["sap/fe/core/CommonUtils", "sap/fe/core/converters/MetaModelConve
       // There is at least one match in the key column:
       // - If the operator is EQ: This indicates an exact key match, so the returned data will be used.
       // - For other operators: One or more keys match the value based on the operator, so the original condition is preserved.
-      return operator === FilterOperator.EQ ? {
+      return cleanedOperator === FilterOperator.EQ ? {
         operator,
         selectedValues: valueHelpKeyQuery.value.map(mapResult)
       } : {
@@ -82,7 +88,7 @@ sap.ui.define(["sap/fe/core/CommonUtils", "sap/fe/core/converters/MetaModelConve
       // The key query did not return any matches, but the search query found results. Use the search results instead.
 
       let results = valueHelpSearchQuery.value.map(mapResult);
-      if (operator === FilterOperator.EQ) {
+      if (cleanedOperator === FilterOperator.EQ) {
         const filteredResults = results.filter(result => result.description.toString().toLowerCase() === valueToMatch.toString().toLowerCase());
         // If the search query is found once/multiple times in the result + operator is EQ, we need to return only those results
         if (filteredResults.length > 0) {
@@ -96,6 +102,7 @@ sap.ui.define(["sap/fe/core/CommonUtils", "sap/fe/core/converters/MetaModelConve
     }
 
     // No matches were found in either query; the original value will be used as a fallback.
+
     return {
       operator,
       selectedValues: [{
@@ -135,32 +142,6 @@ sap.ui.define(["sap/fe/core/CommonUtils", "sap/fe/core/converters/MetaModelConve
   function generateSelectParameter(valueList) {
     return [valueList.keyPath, valueList.descriptionPath].filter(path => path && !path.includes("/")).join(",");
   }
-  _exports.generateSelectParameter = generateSelectParameter;
-  function handleIntervals(operator, resolvedValues) {
-    const [resolvedLowerBound, resolvedUpperBound] = resolvedValues;
-    const result = [];
-    for (const {
-      value: lowerBound,
-      description: lowerBoundText
-    } of resolvedLowerBound.selectedValues) {
-      for (const {
-        value: upperBound,
-        description: upperBoundText
-      } of resolvedUpperBound.selectedValues) {
-        result.push({
-          operator,
-          selectedValues: [{
-            value: lowerBound,
-            description: lowerBoundText ?? lowerBound
-          }, {
-            value: upperBound,
-            description: upperBoundText ?? upperBound
-          }]
-        });
-      }
-    }
-    return result;
-  }
 
   /**
    * Resolves token-based filter values using a value list.
@@ -169,6 +150,7 @@ sap.ui.define(["sap/fe/core/CommonUtils", "sap/fe/core/converters/MetaModelConve
    * @param looseMatch Whether to perform a loose match on the values.
    * @returns A promise that resolves to an array of resolved filter values.
    */
+  _exports.generateSelectParameter = generateSelectParameter;
   async function resolveTokenValue(valueList, value) {
     let looseMatch = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     const {
@@ -186,9 +168,31 @@ sap.ui.define(["sap/fe/core/CommonUtils", "sap/fe/core/converters/MetaModelConve
       // something went wrong - the key property is not a property of the value list entity
       return unresolvedResult([value]);
     }
-    const resolvedOperator = operator === FilterOperator.BT || operator === FilterOperator.NB ? FilterOperator.EQ : operator; // BT/NB: Use EQ for resolving the lower/upper bounds
-    const resolvedValues = await Promise.all(selectedValues.map(async selectedValue => resolveValueUsingValueList(valueList, keyProperty, resolvedOperator, selectedValue, looseMatch)));
-    return operator === FilterOperator.BT || operator === FilterOperator.NB ? handleIntervals(operator, resolvedValues) : resolvedValues.flat();
+
+    // For comparison operators (GreaterThan, LessThan, Between, etc.), skip backend calls
+    // and return user input directly to EasyFilter
+    if (isComparisonOperator(operator)) {
+      if (operator === FilterOperator.BT || operator === FilterOperator.NB) {
+        // Handle Between/Not Between operators - they expect exactly 2 values
+        const [lowerBound, upperBound] = selectedValues;
+        return [{
+          operator,
+          selectedValues: [{
+            value: lowerBound,
+            description: lowerBound
+          }, {
+            value: upperBound,
+            description: upperBound
+          }]
+        }];
+      } else {
+        // Handle other comparison operators (GT, GE, LT, LE)
+        return unresolvedResult([value]);
+      }
+    } else {
+      const resolvedValues = await Promise.all(selectedValues.map(async selectedValue => resolveValueUsingValueList(valueList, keyProperty, operator, selectedValue, looseMatch)));
+      return resolvedValues.flat();
+    }
   }
 
   /**
@@ -212,7 +216,46 @@ sap.ui.define(["sap/fe/core/CommonUtils", "sap/fe/core/converters/MetaModelConve
       };
     });
   }
+
+  /**
+   * Checks if the operator is a negation operator (NE, NotContains, NotStartsWith, NotEndsWith).
+   * @param operator The filter operator to check.
+   * @returns True if the operator is a negation operator.
+   */
   _exports.unresolvedResult = unresolvedResult;
+  function isNegationOperator(operator) {
+    return [FilterOperator.NE, FilterOperator.NotContains, FilterOperator.NotStartsWith, FilterOperator.NotEndsWith].includes(operator);
+  }
+
+  /**
+   * Checks if the operator is a comparison operator (GT, GE, LT, LE, BT, NB).
+   * @param operator The filter operator to check.
+   * @returns True if the operator is a comparison operator.
+   */
+  function isComparisonOperator(operator) {
+    return [FilterOperator.GT, FilterOperator.GE, FilterOperator.LT, FilterOperator.LE, FilterOperator.BT, FilterOperator.NB].includes(operator);
+  }
+
+  /**
+   * Converts a negation operator to its positive equivalent (NE -> EQ, NotContains -> Contains, etc.).
+   * @param negationOperator The negation operator to convert.
+   * @returns The corresponding positive operator.
+   */
+  function getPositiveOperator(negationOperator) {
+    switch (negationOperator) {
+      case FilterOperator.NE:
+        return FilterOperator.EQ;
+      case FilterOperator.NotContains:
+        return FilterOperator.Contains;
+      case FilterOperator.NotStartsWith:
+        return FilterOperator.StartsWith;
+      case FilterOperator.NotEndsWith:
+        return FilterOperator.EndsWith;
+      default:
+        return FilterOperator.EQ;
+    }
+  }
+  _exports.getPositiveOperator = getPositiveOperator;
   return _exports;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["getKeyPropertyFilter","valueList","keyProperty","operator","valueToMatch","filterValue","annotations","Common","IsUpperCase","valueOf","toUpperCase","Filter","path","keyPath","value1","resolveValueUsingValueList","looseMatch","arguments","length","undefined","model","valueListInfo","$model","CollectionPath","$select","generateSelectParameter","$search","CommonUtils","normalizeSearchTerm","Date","toISOString","toString","keyPropertyFilter","characterLimitOverflow","maxLength","valueHelpKeyQuery","valueHelpSearchQuery","Promise","allSettled","bindList","requestContexts","mapResult","mapValueListToCodeList","status","value","FilterOperator","EQ","selectedValues","map","description","results","filteredResults","filter","result","toLowerCase","noMatch","ensureDescription","context","data","getObject","descriptionPath","_exports","includes","join","handleIntervals","resolvedValues","resolvedLowerBound","resolvedUpperBound","lowerBound","lowerBoundText","upperBound","upperBoundText","push","resolveTokenValue","setContinueOnError","valueListMetamodel","convertTypes","getMetaModel","resolvePath","target","isProperty","unresolvedResult","resolvedOperator","BT","NB","all","selectedValue","flat","values","_ref"],"sourceRoot":".","sources":["EasyFilterDataFetcher.ts"],"sourcesContent":["import type { Property } from \"@sap-ux/vocabularies-types\";\nimport type {\n\tCodeListType,\n\tTokenSelectedValuesDefinition,\n\tValueHelpSelectedValuesDefinition\n} from \"sap/fe/controls/easyFilter/EasyFilterBarContainer\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport { convertTypes } from \"sap/fe/core/converters/MetaModelConverter\";\nimport { isProperty } from \"sap/fe/core/helpers/TypeGuards\";\nimport { type ValueListInfo } from \"sap/fe/macros/internal/valuehelp/ValueListHelper\";\nimport type Context from \"sap/ui/model/Context\";\nimport Filter from \"sap/ui/model/Filter\";\nimport FilterOperator from \"sap/ui/model/FilterOperator\";\nimport type { CodeListEntry } from \"ux/eng/fioriai/reuse/easyfilter/EasyFilter\";\n\ntype ScalarOperator = Exclude<FilterOperator, FilterOperator.BT | FilterOperator.NB>;\ntype ScalarValue = string | boolean | number | Date;\n\n/**\n * Generates a filter for the key property of a value list.\n * @param valueList The value list information.\n * @param keyProperty The key property of the value list.\n * @param operator The filter operator.\n * @param valueToMatch The value to match.\n * @returns A filter for the key property.\n */\nfunction getKeyPropertyFilter(\n\tvalueList: ValueListInfo,\n\tkeyProperty: Property,\n\toperator: ScalarOperator,\n\tvalueToMatch: ScalarValue\n): Filter {\n\tlet filterValue = valueToMatch;\n\n\t// If the key property is known to contain only uppercase values, convert the filter value to uppercase as well\n\tif (typeof filterValue === \"string\" && keyProperty.annotations.Common?.IsUpperCase?.valueOf() === true) {\n\t\tfilterValue = filterValue.toUpperCase();\n\t}\n\n\treturn new Filter({ path: valueList.keyPath, operator, value1: filterValue });\n}\n\n/**\n * Resolves a single scalar value using a value list.\n * @param valueList The value list information.\n * @param keyProperty The key property of the value list.\n * @param operator The filter operator.\n * @param valueToMatch The value to match.\n * @param looseMatch Whether to apply loose matching or not\n * @returns A promise that resolves to the selected values.\n */\nasync function resolveValueUsingValueList(\n\tvalueList: ValueListInfo,\n\tkeyProperty: Property,\n\toperator: ScalarOperator,\n\tvalueToMatch: ScalarValue,\n\tlooseMatch = false\n): Promise<ValueHelpSelectedValuesDefinition> {\n\tconst model = valueList.valueListInfo.$model;\n\tconst path = `/${valueList.valueListInfo.CollectionPath}`;\n\tconst $select = generateSelectParameter(valueList);\n\tlet $search = CommonUtils.normalizeSearchTerm(valueToMatch instanceof Date ? valueToMatch.toISOString() : valueToMatch.toString());\n\tconst keyPropertyFilter = getKeyPropertyFilter(valueList, keyProperty, operator, valueToMatch);\n\n\t// Check if the query exceeds the maximum length of the key property\n\tconst characterLimitOverflow = !$search || $search.length > (keyProperty.maxLength ?? $search.length);\n\n\tif (!looseMatch) {\n\t\t$search = `\"${$search}\"`; // Ensure the search term is treated as a phrase\n\t}\n\t// If query exceeds the maximum length of the key property, we don't filter at all, as it would give no result anyway\n\tconst [valueHelpKeyQuery, valueHelpSearchQuery] = await Promise.allSettled([\n\t\t!characterLimitOverflow ? model.bindList(path, undefined, undefined, keyPropertyFilter, { $select }).requestContexts(0, 1) : [], // $filter on the key property of the value list\n\t\tmodel.bindList(path, undefined, undefined, undefined, { $search: $search, $select }).requestContexts() // $search on the value list\n\t]);\n\n\tconst mapResult = mapValueListToCodeList(valueList, true);\n\n\tif (valueHelpKeyQuery.status === \"fulfilled\" && valueHelpKeyQuery.value.length > 0) {\n\t\t// There is at least one match in the key column:\n\t\t// - If the operator is EQ: This indicates an exact key match, so the returned data will be used.\n\t\t// - For other operators: One or more keys match the value based on the operator, so the original condition is preserved.\n\t\treturn operator === FilterOperator.EQ\n\t\t\t? { operator, selectedValues: valueHelpKeyQuery.value.map(mapResult) }\n\t\t\t: { operator, selectedValues: [{ value: valueToMatch, description: valueToMatch }] };\n\t}\n\n\tif (valueHelpSearchQuery.status === \"fulfilled\" && valueHelpSearchQuery.value.length > 0) {\n\t\t// The key query did not return any matches, but the search query found results. Use the search results instead.\n\n\t\tlet results = valueHelpSearchQuery.value.map(mapResult);\n\n\t\tif (operator === FilterOperator.EQ) {\n\t\t\tconst filteredResults = results.filter(\n\t\t\t\t(result) => result.description.toString().toLowerCase() === valueToMatch.toString().toLowerCase()\n\t\t\t);\n\t\t\t// If the search query is found once/multiple times in the result + operator is EQ, we need to return only those results\n\t\t\tif (filteredResults.length > 0) {\n\t\t\t\tresults = filteredResults;\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\toperator,\n\t\t\tselectedValues: results\n\t\t};\n\t}\n\n\t// No matches were found in either query; the original value will be used as a fallback.\n\treturn { operator, selectedValues: [{ value: valueToMatch, description: valueToMatch }], noMatch: true };\n}\n\n/**\n * Create a mapping function for mapping a value list query result to a code list.\n * @param valueList The value list information used to identify the key and description properties.\n * @param ensureDescription Whether to ensure that the description is always returned.\n * @returns A function that maps a single value list query result to a code list entry.\n */\nexport function mapValueListToCodeList(valueList: ValueListInfo, ensureDescription: true): (context: Context) => CodeListType;\nexport function mapValueListToCodeList(valueList: ValueListInfo, ensureDescription?: false): (context: Context) => CodeListEntry;\nexport function mapValueListToCodeList(\n\tvalueList: ValueListInfo,\n\tensureDescription = false\n): (context: Context) => CodeListEntry | CodeListType {\n\treturn (context: Context): CodeListEntry => {\n\t\tconst data = context.getObject();\n\t\tconst value = data[valueList.keyPath];\n\t\tconst description = valueList.descriptionPath ? data[valueList.descriptionPath] : undefined;\n\t\treturn { value, description: ensureDescription ? description ?? value : description };\n\t};\n}\n\n/**\n * Generates the $select parameter for a value list query.\n * @param valueList The value list information.\n * @returns The $select parameter as a string.\n */\nexport function generateSelectParameter(valueList: ValueListInfo): string {\n\treturn [valueList.keyPath, valueList.descriptionPath].filter((path) => path && !path.includes(\"/\")).join(\",\");\n}\n\nfunction handleIntervals(\n\toperator: FilterOperator.BT | FilterOperator.NB,\n\tresolvedValues: ValueHelpSelectedValuesDefinition[]\n): ValueHelpSelectedValuesDefinition[] {\n\tconst [resolvedLowerBound, resolvedUpperBound] = resolvedValues;\n\n\tconst result: ValueHelpSelectedValuesDefinition[] = [];\n\tfor (const { value: lowerBound, description: lowerBoundText } of resolvedLowerBound.selectedValues) {\n\t\tfor (const { value: upperBound, description: upperBoundText } of resolvedUpperBound.selectedValues) {\n\t\t\tresult.push({\n\t\t\t\toperator,\n\t\t\t\tselectedValues: [\n\t\t\t\t\t{ value: lowerBound, description: lowerBoundText ?? lowerBound },\n\t\t\t\t\t{ value: upperBound, description: upperBoundText ?? upperBound }\n\t\t\t\t]\n\t\t\t});\n\t\t}\n\t}\n\treturn result;\n}\n\n/**\n * Resolves token-based filter values using a value list.\n * @param valueList The value list used for resolving values.\n * @param value The token-based filter values to resolve.\n * @param looseMatch Whether to perform a loose match on the values.\n * @returns A promise that resolves to an array of resolved filter values.\n */\nexport async function resolveTokenValue(\n\tvalueList: ValueListInfo,\n\tvalue: TokenSelectedValuesDefinition,\n\tlooseMatch = false\n): Promise<ValueHelpSelectedValuesDefinition[]> {\n\tconst { operator, selectedValues } = value;\n\tconst model = valueList.valueListInfo.$model;\n\n\t// Make sure all values are resolved, even if some requests fail. It can happen that the backend cannot process the $filter queries we\n\t// run on the value list, but we still want to get the fallback $search results.\n\tmodel.setContinueOnError(\"$auto\");\n\n\tconst valueListMetamodel = convertTypes(model.getMetaModel());\n\tconst keyProperty = valueListMetamodel.resolvePath(`/${valueList.valueListInfo.CollectionPath}/${valueList.keyPath}`)?.target;\n\n\tif (!isProperty(keyProperty)) {\n\t\t// something went wrong - the key property is not a property of the value list entity\n\t\treturn unresolvedResult([value]);\n\t}\n\n\tconst resolvedOperator = operator === FilterOperator.BT || operator === FilterOperator.NB ? FilterOperator.EQ : operator; // BT/NB: Use EQ for resolving the lower/upper bounds\n\tconst resolvedValues = await Promise.all(\n\t\tselectedValues.map(async (selectedValue) =>\n\t\t\tresolveValueUsingValueList(valueList, keyProperty, resolvedOperator, selectedValue, looseMatch)\n\t\t)\n\t);\n\n\treturn operator === FilterOperator.BT || operator === FilterOperator.NB\n\t\t? handleIntervals(operator, resolvedValues)\n\t\t: resolvedValues.flat();\n}\n\n/**\n * Returns the unresolved values in the format expected by the Easy Filter Bar.\n * @param values The values to be resolved.\n * @returns An array of unresolved values.\n */\nexport function unresolvedResult(values: TokenSelectedValuesDefinition[]): ValueHelpSelectedValuesDefinition[] {\n\treturn values.map(({ operator, selectedValues }) => ({\n\t\toperator,\n\t\tselectedValues: selectedValues.map((value) => ({ value, description: value }))\n\t})) as ValueHelpSelectedValuesDefinition[];\n}\n"],"mappings":"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","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["getKeyPropertyFilter","valueList","keyProperty","operator","valueToMatch","filterValue","annotations","Common","IsUpperCase","valueOf","toUpperCase","Filter","path","keyPath","value1","resolveValueUsingValueList","looseMatch","arguments","length","undefined","model","valueListInfo","$model","CollectionPath","$select","generateSelectParameter","$search","CommonUtils","normalizeSearchTerm","Date","toISOString","toString","isNegation","isNegationOperator","cleanedOperator","getPositiveOperator","keyPropertyFilter","characterLimitOverflow","maxLength","valueHelpKeyQuery","valueHelpSearchQuery","Promise","allSettled","bindList","requestContexts","mapResult","mapValueListToCodeList","status","value","FilterOperator","EQ","selectedValues","map","description","results","filteredResults","filter","result","toLowerCase","noMatch","ensureDescription","context","data","getObject","descriptionPath","_exports","includes","join","resolveTokenValue","setContinueOnError","valueListMetamodel","convertTypes","getMetaModel","resolvePath","target","isProperty","unresolvedResult","isComparisonOperator","BT","NB","lowerBound","upperBound","resolvedValues","all","selectedValue","flat","values","_ref","NE","NotContains","NotStartsWith","NotEndsWith","GT","GE","LT","LE","negationOperator","Contains","StartsWith","EndsWith"],"sourceRoot":".","sources":["EasyFilterDataFetcher.ts"],"sourcesContent":["import type { Property } from \"@sap-ux/vocabularies-types\";\nimport type {\n\tCodeListType,\n\tTokenSelectedValuesDefinition,\n\tValueHelpBetweenSelectedValues,\n\tValueHelpSelectedValuesDefinition\n} from \"sap/fe/controls/easyFilter/EasyFilterBarContainer\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport { convertTypes } from \"sap/fe/core/converters/MetaModelConverter\";\nimport { isProperty } from \"sap/fe/core/helpers/TypeGuards\";\nimport { type ValueListInfo } from \"sap/fe/macros/internal/valuehelp/ValueListHelper\";\nimport type Context from \"sap/ui/model/Context\";\nimport Filter from \"sap/ui/model/Filter\";\nimport FilterOperator from \"sap/ui/model/FilterOperator\";\nimport type { CodeListEntry } from \"ux/eng/fioriai/reuse/easyfilter/EasyFilter\";\n\ntype ScalarOperator = Exclude<FilterOperator, FilterOperator.BT | FilterOperator.NB>;\ntype ScalarValue = string | boolean | number | Date;\n\n/**\n * Generates a filter for the key property of a value list.\n * @param valueList The value list information.\n * @param keyProperty The key property of the value list.\n * @param operator The filter operator.\n * @param valueToMatch The value to match.\n * @returns A filter for the key property.\n */\nfunction getKeyPropertyFilter(\n\tvalueList: ValueListInfo,\n\tkeyProperty: Property,\n\toperator: ScalarOperator,\n\tvalueToMatch: ScalarValue\n): Filter {\n\tlet filterValue = valueToMatch;\n\n\t// If the key property is known to contain only uppercase values, convert the filter value to uppercase as well\n\tif (typeof filterValue === \"string\" && keyProperty.annotations.Common?.IsUpperCase?.valueOf() === true) {\n\t\tfilterValue = filterValue.toUpperCase();\n\t}\n\n\treturn new Filter({ path: valueList.keyPath, operator, value1: filterValue });\n}\n\n/**\n * Resolves a single scalar value using a value list.\n * @param valueList The value list information.\n * @param keyProperty The key property of the value list.\n * @param operator The filter operator.\n * @param valueToMatch The value to match.\n * @param looseMatch Whether to apply loose matching or not\n * @returns A promise that resolves to the selected values.\n */\nasync function resolveValueUsingValueList(\n\tvalueList: ValueListInfo,\n\tkeyProperty: Property,\n\toperator: ScalarOperator,\n\tvalueToMatch: ScalarValue,\n\tlooseMatch = false\n): Promise<ValueHelpSelectedValuesDefinition> {\n\tconst model = valueList.valueListInfo.$model;\n\tconst path = `/${valueList.valueListInfo.CollectionPath}`;\n\tconst $select = generateSelectParameter(valueList);\n\tlet $search = CommonUtils.normalizeSearchTerm(valueToMatch instanceof Date ? valueToMatch.toISOString() : valueToMatch.toString());\n\n\t// Handle negation operators (NE, NotContains, NotStartsWith, NotEndsWith)\n\t// Strategy: Query for positive case, then apply negation client-side\n\tconst isNegation = isNegationOperator(operator);\n\t// \"cleaned\" operator for possible negation operators\n\tconst cleanedOperator = isNegation ? getPositiveOperator(operator) : operator;\n\tconst keyPropertyFilter = getKeyPropertyFilter(valueList, keyProperty, cleanedOperator, valueToMatch);\n\n\t// Check if the query exceeds the maximum length of the key property\n\tconst characterLimitOverflow = !$search || $search.length > (keyProperty.maxLength ?? $search.length);\n\n\tif (!looseMatch) {\n\t\t$search = `\"${$search}\"`; // Ensure the search term is treated as a phrase\n\t}\n\t// If query exceeds the maximum length of the key property, we don't filter at all, as it would give no result anyway\n\tconst [valueHelpKeyQuery, valueHelpSearchQuery] = await Promise.allSettled([\n\t\t!characterLimitOverflow ? model.bindList(path, undefined, undefined, keyPropertyFilter, { $select }).requestContexts(0, 1) : [], // $filter on the key property of the value list\n\t\tmodel.bindList(path, undefined, undefined, undefined, { $search: $search, $select }).requestContexts() // $search on the value list\n\t]);\n\n\tconst mapResult = mapValueListToCodeList(valueList, true);\n\n\tif (valueHelpKeyQuery.status === \"fulfilled\" && valueHelpKeyQuery.value.length > 0) {\n\t\t// There is at least one match in the key column:\n\t\t// - If the operator is EQ: This indicates an exact key match, so the returned data will be used.\n\t\t// - For other operators: One or more keys match the value based on the operator, so the original condition is preserved.\n\t\treturn cleanedOperator === FilterOperator.EQ\n\t\t\t? { operator, selectedValues: valueHelpKeyQuery.value.map(mapResult) }\n\t\t\t: {\n\t\t\t\t\toperator,\n\t\t\t\t\tselectedValues: [{ value: valueToMatch, description: valueToMatch }]\n\t\t\t  };\n\t}\n\n\tif (valueHelpSearchQuery.status === \"fulfilled\" && valueHelpSearchQuery.value.length > 0) {\n\t\t// The key query did not return any matches, but the search query found results. Use the search results instead.\n\n\t\tlet results = valueHelpSearchQuery.value.map(mapResult);\n\n\t\tif (cleanedOperator === FilterOperator.EQ) {\n\t\t\tconst filteredResults = results.filter(\n\t\t\t\t(result) => result.description.toString().toLowerCase() === valueToMatch.toString().toLowerCase()\n\t\t\t);\n\t\t\t// If the search query is found once/multiple times in the result + operator is EQ, we need to return only those results\n\t\t\tif (filteredResults.length > 0) {\n\t\t\t\tresults = filteredResults;\n\t\t\t}\n\t\t}\n\n\t\treturn { operator, selectedValues: results };\n\t}\n\n\t// No matches were found in either query; the original value will be used as a fallback.\n\n\treturn {\n\t\toperator,\n\t\tselectedValues: [{ value: valueToMatch, description: valueToMatch }],\n\t\tnoMatch: true\n\t};\n}\n\n/**\n * Create a mapping function for mapping a value list query result to a code list.\n * @param valueList The value list information used to identify the key and description properties.\n * @param ensureDescription Whether to ensure that the description is always returned.\n * @returns A function that maps a single value list query result to a code list entry.\n */\nexport function mapValueListToCodeList(valueList: ValueListInfo, ensureDescription: true): (context: Context) => CodeListType;\nexport function mapValueListToCodeList(valueList: ValueListInfo, ensureDescription?: false): (context: Context) => CodeListEntry;\nexport function mapValueListToCodeList(\n\tvalueList: ValueListInfo,\n\tensureDescription = false\n): (context: Context) => CodeListEntry | CodeListType {\n\treturn (context: Context): CodeListEntry => {\n\t\tconst data = context.getObject();\n\t\tconst value = data[valueList.keyPath];\n\t\tconst description = valueList.descriptionPath ? data[valueList.descriptionPath] : undefined;\n\t\treturn { value, description: ensureDescription ? description ?? value : description };\n\t};\n}\n\n/**\n * Generates the $select parameter for a value list query.\n * @param valueList The value list information.\n * @returns The $select parameter as a string.\n */\nexport function generateSelectParameter(valueList: ValueListInfo): string {\n\treturn [valueList.keyPath, valueList.descriptionPath].filter((path) => path && !path.includes(\"/\")).join(\",\");\n}\n\n/**\n * Resolves token-based filter values using a value list.\n * @param valueList The value list used for resolving values.\n * @param value The token-based filter values to resolve.\n * @param looseMatch Whether to perform a loose match on the values.\n * @returns A promise that resolves to an array of resolved filter values.\n */\nexport async function resolveTokenValue(\n\tvalueList: ValueListInfo,\n\tvalue: TokenSelectedValuesDefinition,\n\tlooseMatch = false\n): Promise<ValueHelpSelectedValuesDefinition[]> {\n\tconst { operator, selectedValues } = value;\n\tconst model = valueList.valueListInfo.$model;\n\n\t// Make sure all values are resolved, even if some requests fail. It can happen that the backend cannot process the $filter queries we\n\t// run on the value list, but we still want to get the fallback $search results.\n\tmodel.setContinueOnError(\"$auto\");\n\n\tconst valueListMetamodel = convertTypes(model.getMetaModel());\n\tconst keyProperty = valueListMetamodel.resolvePath(`/${valueList.valueListInfo.CollectionPath}/${valueList.keyPath}`)?.target;\n\n\tif (!isProperty(keyProperty)) {\n\t\t// something went wrong - the key property is not a property of the value list entity\n\t\treturn unresolvedResult([value]);\n\t}\n\n\t// For comparison operators (GreaterThan, LessThan, Between, etc.), skip backend calls\n\t// and return user input directly to EasyFilter\n\tif (isComparisonOperator(operator)) {\n\t\tif (operator === FilterOperator.BT || operator === FilterOperator.NB) {\n\t\t\t// Handle Between/Not Between operators - they expect exactly 2 values\n\t\t\tconst [lowerBound, upperBound] = selectedValues;\n\t\t\treturn [\n\t\t\t\t{\n\t\t\t\t\toperator,\n\t\t\t\t\tselectedValues: [\n\t\t\t\t\t\t{ value: lowerBound, description: lowerBound },\n\t\t\t\t\t\t{ value: upperBound, description: upperBound }\n\t\t\t\t\t] as ValueHelpBetweenSelectedValues\n\t\t\t\t}\n\t\t\t];\n\t\t} else {\n\t\t\t// Handle other comparison operators (GT, GE, LT, LE)\n\t\t\treturn unresolvedResult([value]);\n\t\t}\n\t} else {\n\t\tconst resolvedValues = await Promise.all(\n\t\t\tselectedValues.map(async (selectedValue) =>\n\t\t\t\tresolveValueUsingValueList(valueList, keyProperty, operator as ScalarOperator, selectedValue, looseMatch)\n\t\t\t)\n\t\t);\n\t\treturn resolvedValues.flat();\n\t}\n}\n\n/**\n * Returns the unresolved values in the format expected by the Easy Filter Bar.\n * @param values The values to be resolved.\n * @returns An array of unresolved values.\n */\nexport function unresolvedResult(values: TokenSelectedValuesDefinition[]): ValueHelpSelectedValuesDefinition[] {\n\treturn values.map(({ operator, selectedValues }) => ({\n\t\toperator,\n\t\tselectedValues: selectedValues.map((value) => ({ value, description: value }))\n\t})) as ValueHelpSelectedValuesDefinition[];\n}\n\n/**\n * Checks if the operator is a negation operator (NE, NotContains, NotStartsWith, NotEndsWith).\n * @param operator The filter operator to check.\n * @returns True if the operator is a negation operator.\n */\nfunction isNegationOperator(operator: FilterOperator): boolean {\n\treturn [FilterOperator.NE, FilterOperator.NotContains, FilterOperator.NotStartsWith, FilterOperator.NotEndsWith].includes(operator);\n}\n\n/**\n * Checks if the operator is a comparison operator (GT, GE, LT, LE, BT, NB).\n * @param operator The filter operator to check.\n * @returns True if the operator is a comparison operator.\n */\nfunction isComparisonOperator(operator: FilterOperator): boolean {\n\treturn [FilterOperator.GT, FilterOperator.GE, FilterOperator.LT, FilterOperator.LE, FilterOperator.BT, FilterOperator.NB].includes(\n\t\toperator\n\t);\n}\n\n/**\n * Converts a negation operator to its positive equivalent (NE -> EQ, NotContains -> Contains, etc.).\n * @param negationOperator The negation operator to convert.\n * @returns The corresponding positive operator.\n */\nexport function getPositiveOperator(negationOperator: FilterOperator): ScalarOperator {\n\tswitch (negationOperator) {\n\t\tcase FilterOperator.NE:\n\t\t\treturn FilterOperator.EQ;\n\t\tcase FilterOperator.NotContains:\n\t\t\treturn FilterOperator.Contains;\n\t\tcase FilterOperator.NotStartsWith:\n\t\t\treturn FilterOperator.StartsWith;\n\t\tcase FilterOperator.NotEndsWith:\n\t\t\treturn FilterOperator.EndsWith;\n\t\tdefault:\n\t\t\treturn FilterOperator.EQ;\n\t}\n}\n"],"mappings":"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","ignoreList":[]}