@sapui5/sap.fe.core 1.141.2 → 1.142.1

package/src/sap/fe/core/converters/controls/Common/filter/FilterRestrictions.js

@@ -0,0 +1,243 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2025 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/util/array/uniqueSort", "sap/base/util/merge", "sap/fe/core/helpers/TypeGuards"], function (uniqueSort, mergeObjects, TypeGuards) {
+  "use strict";
+
+  var isEntitySet = TypeGuards.isEntitySet;
+  /**
+   * Extracts property path string from a flexible path object used in converter or annotation inputs.
+   * The object may contain a 'value' field. Returns undefined if it is a non-empty string.
+   * @param ref Potential property reference object.
+   * @returns Property path string or undefined.
+   */
+  function extractPath(ref) {
+    if (!ref) {
+      return undefined;
+    }
+    return typeof ref.value === "string" ? ref.value : undefined;
+  }
+
+  /**
+   * Parses raw FilterRestrictionsType annotation into plain arrays of strings and a mapping of allowed expressions.
+   * This replaces previous two-step normalization + extraction logic and deliberately avoids introducing $PropertyPath objects.
+   * @param filterRestrictions Raw filter restrictions annotation (may be undefined).
+   * @returns Parsed filter restrictions with simple string collections.
+   */
+  function getFilterRestrictions(filterRestrictions) {
+    if (!filterRestrictions) {
+      return {
+        RequiredProperties: [],
+        NonFilterableProperties: [],
+        FilterAllowedExpressions: {}
+      };
+    }
+    const required = (filterRestrictions.RequiredProperties ?? []).map(p => extractPath(p)).filter(p => !!p);
+    const nonFilterable = (filterRestrictions.NonFilterableProperties ?? []).map(p => extractPath(p)).filter(p => !!p);
+    const allowed = {};
+    for (const expr of filterRestrictions.FilterExpressionRestrictions ?? []) {
+      const exprObj = expr;
+      const propPath = extractPath(exprObj.Property);
+      const allowedExp = typeof exprObj.AllowedExpressions === "string" ? exprObj.AllowedExpressions : undefined;
+      if (!propPath || !allowedExp) {
+        continue;
+      }
+      if (allowed[propPath] !== undefined) {
+        allowed[propPath].push(allowedExp);
+      } else {
+        allowed[propPath] = [allowedExp];
+      }
+    }
+    return {
+      RequiredProperties: required,
+      NonFilterableProperties: nonFilterable,
+      FilterAllowedExpressions: allowed
+    };
+  }
+  function _fetchPropertiesForNavPath(paths, navPath, props) {
+    const navPathPrefix = navPath + "/";
+    return paths.reduce((outPaths, pathToCheck) => {
+      if (pathToCheck.startsWith(navPathPrefix)) {
+        const outPath = pathToCheck.replace(navPathPrefix, "");
+        if (!outPaths.includes(outPath)) {
+          outPaths.push(outPath);
+        }
+      }
+      return outPaths;
+    }, props);
+  }
+
+  /**
+   * Initializes an empty filter restrictions object with default values.
+   * @returns The initialized filter restrictions object
+   */
+  function initializeFilterRestrictions() {
+    return {
+      RequiredProperties: [],
+      NonFilterableProperties: [],
+      FilterAllowedExpressions: {}
+    };
+  }
+
+  /**
+   * Determines if the entity set has a result context annotation.
+   * @param entitySet The entity set to check
+   * @returns True if the entity set has result context, false otherwise
+   */
+  function hasResultContext(entitySet) {
+    if (!entitySet?.annotations?.Common) {
+      return false;
+    }
+    return "ResultContext" in entitySet.annotations.Common ? entitySet.annotations.Common.ResultContext?.valueOf() === true : false;
+  }
+
+  /**
+   * Processes filter restrictions at entity set level (least priority).
+   * @param restrictions The current filter restrictions object
+   * @param filterRestrictions The filter restrictions annotation
+   * @param hasResultContextValue Whether the entity has result context
+   * @returns Updated filter restrictions object
+   */
+  function processEntitySetFilterRestrictions(restrictions, filterRestrictions, hasResultContextValue) {
+    const filterRestictions = getFilterRestrictions(filterRestrictions);
+    restrictions.RequiredProperties = filterRestictions.RequiredProperties;
+    if (!hasResultContextValue) {
+      restrictions.NonFilterableProperties = filterRestictions.NonFilterableProperties;
+    }
+    restrictions.FilterAllowedExpressions = filterRestictions.FilterAllowedExpressions;
+    return restrictions;
+  }
+
+  /**
+   * Processes property path filter restrictions (third highest priority).
+   * @param restrictions The current filter restrictions object
+   * @param filterRestrictions The parent filter restrictions
+   * @param navPath The navigation path
+   * @returns Updated filter restrictions object
+   */
+  function processPropertyPathFilterRestrictions(restrictions, filterRestrictions, navPath) {
+    if (!filterRestrictions || navPath.includes("%2F")) {
+      return restrictions;
+    }
+    const filterRestictions = getFilterRestrictions(filterRestrictions);
+    const navPrefix = navPath + "/";
+    const reqSubset = filterRestictions.RequiredProperties.filter(p => p.startsWith(navPrefix)).map(p => p.slice(navPrefix.length));
+    const nonFilterSubset = filterRestictions.NonFilterableProperties.filter(p => p.startsWith(navPrefix)).map(p => p.slice(navPrefix.length));
+    restrictions.RequiredProperties = _fetchPropertiesForNavPath(reqSubset, navPath, restrictions.RequiredProperties);
+    restrictions.NonFilterableProperties = _fetchPropertiesForNavPath(nonFilterSubset, navPath, restrictions.NonFilterableProperties);
+    const parentAllowedExpressions = Object.keys(filterRestictions.FilterAllowedExpressions).reduce((outProp, propPath) => {
+      if (propPath.startsWith(navPrefix)) {
+        const outPropPath = propPath.slice(navPrefix.length);
+        outProp[outPropPath] = filterRestictions.FilterAllowedExpressions[propPath];
+      }
+      return outProp;
+    }, {});
+    restrictions.FilterAllowedExpressions = mergeObjects({}, restrictions.FilterAllowedExpressions, parentAllowedExpressions);
+    return restrictions;
+  }
+
+  /**
+   * Processes navigation restrictions (second highest priority).
+   * @param restrictions The current filter restrictions object
+   * @param navigationRestrictions The navigation restrictions
+   * @returns Updated filter restrictions object
+   */
+  function processNavigationFilterRestrictions(restrictions, navigationRestrictions) {
+    const filterRestictions = getFilterRestrictions(navigationRestrictions);
+    restrictions.RequiredProperties = uniqueSort(restrictions.RequiredProperties.concat(filterRestictions.RequiredProperties));
+    restrictions.NonFilterableProperties = uniqueSort(restrictions.NonFilterableProperties.concat(filterRestictions.NonFilterableProperties));
+    restrictions.FilterAllowedExpressions = mergeObjects({}, restrictions.FilterAllowedExpressions, filterRestictions.FilterAllowedExpressions);
+    return restrictions;
+  }
+
+  /**
+   * Processes navigation association entity restrictions (highest priority).
+   * @param restrictions The current filter restrictions object
+   * @param associationRestrictions The association entity filter restrictions
+   * @returns Updated filter restrictions object
+   */
+  function processNavigationAssociationFilterRestrictions(restrictions, associationRestrictions) {
+    const filterRestictions = getFilterRestrictions(associationRestrictions);
+    restrictions.RequiredProperties = uniqueSort(restrictions.RequiredProperties.concat(filterRestictions.RequiredProperties));
+    restrictions.NonFilterableProperties = uniqueSort(restrictions.NonFilterableProperties.concat(filterRestictions.NonFilterableProperties));
+    restrictions.FilterAllowedExpressions = mergeObjects({}, restrictions.FilterAllowedExpressions, filterRestictions.FilterAllowedExpressions);
+    return restrictions;
+  }
+
+  /**
+   * Processes filter restrictions using converter context.
+   * @param dataModelObjectPath The data model object path
+   * @returns Processed filter restrictions
+   */
+  function processFilterRestrictionsFromConverter(dataModelObjectPath) {
+    const restrictions = initializeFilterRestrictions();
+    const isContainment = !isEntitySet(dataModelObjectPath.targetEntitySet);
+    const containmentNavPath = isContainment && dataModelObjectPath.navigationProperties[dataModelObjectPath.navigationProperties.length - 1]?.name;
+
+    // LEAST PRIORITY - Filter restrictions directly at Entity Set
+    if (!isContainment) {
+      const entitySetFilterRestrictions = dataModelObjectPath.targetEntitySet?.annotations?.Capabilities?.FilterRestrictions;
+      const hasResultContextValue = hasResultContext(dataModelObjectPath.targetEntitySet);
+      processEntitySetFilterRestrictions(restrictions, entitySetFilterRestrictions, hasResultContextValue);
+    }
+    if (dataModelObjectPath.navigationProperties.length > 0) {
+      const navPath = isContainment ? containmentNavPath : dataModelObjectPath.navigationProperties[dataModelObjectPath.navigationProperties.length - 1]?.name;
+
+      // THIRD HIGHEST PRIORITY - Property path restrictions at parent entity
+      const parentFilterRestrictions = dataModelObjectPath.startingEntitySet?.annotations?.Capabilities?.FilterRestrictions;
+      processPropertyPathFilterRestrictions(restrictions, parentFilterRestrictions, navPath);
+
+      // SECOND HIGHEST PRIORITY - Navigation restrictions from parent entity set
+      // Build the full navigation path dynamically
+      const navigationPathParts = dataModelObjectPath.navigationProperties.map(prop => prop.name);
+
+      // Check for navigation restrictions that match any part of our navigation path
+      const navigationRestrictions = dataModelObjectPath.startingEntitySet?.annotations?.Capabilities?.NavigationRestrictions?.RestrictedProperties?.find(navProp => {
+        const navPropPath = navProp.NavigationProperty.value;
+        if (!navPropPath) {
+          return false;
+        }
+
+        // Check if the navigation property path matches any of our navigation segments
+        // This handles both single level (e.g., "_PartnerItems") and multi-level (e.g., "Set/_PartnerItems") paths
+        const isPartialPathMatch = navigationPathParts.some((_, index) => {
+          const partialPath = navigationPathParts.slice(index).join("/");
+          return navPropPath === partialPath;
+        });
+
+        // Also check the full path
+        const fullPath = navigationPathParts.join("/");
+        return isPartialPathMatch || navPropPath === fullPath;
+      });
+      const navFilterRestrictions = navigationRestrictions?.FilterRestrictions;
+      processNavigationFilterRestrictions(restrictions, navFilterRestrictions);
+
+      // HIGHEST PRIORITY - Navigation association entity restrictions
+      const navigationAssociation = dataModelObjectPath.navigationProperties.find(navProp => navProp.name === navPath);
+      const associationFilterRestrictions = navigationAssociation?.annotations?.Capabilities?.FilterRestrictions;
+      processNavigationAssociationFilterRestrictions(restrictions, associationFilterRestrictions);
+    }
+    return restrictions;
+  }
+
+  /*** Fetches filter restrictions by entity path with proper priority handling and ensures correct processing order by following priority order:
+   * 1. LEAST PRIORITY: Filter restrictions directly at Entity Set
+   * 2. THIRD HIGHEST PRIORITY: Property path restrictions at parent entity
+   * 3. SECOND HIGHEST PRIORITY: Navigation restrictions
+   * 4. HIGHEST PRIORITY: Restrictions at navigation association entity
+   * @param converterContext Optional converter context for enhanced processing
+   * @returns Filter restrictions object containing required properties, non-filterable properties, and allowed expressions
+   */
+  function getFilterRestrictionsByDataModel(dataModelObjectPath) {
+    if (dataModelObjectPath) {
+      return processFilterRestrictionsFromConverter(dataModelObjectPath);
+    }
+    return initializeFilterRestrictions();
+  }
+  const FilterRestrictions = {
+    getFilterRestrictionsByDataModel
+  };
+  return FilterRestrictions;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["extractPath","ref","undefined","value","getFilterRestrictions","filterRestrictions","RequiredProperties","NonFilterableProperties","FilterAllowedExpressions","required","map","p","filter","nonFilterable","allowed","expr","FilterExpressionRestrictions","exprObj","propPath","Property","allowedExp","AllowedExpressions","push","_fetchPropertiesForNavPath","paths","navPath","props","navPathPrefix","reduce","outPaths","pathToCheck","startsWith","outPath","replace","includes","initializeFilterRestrictions","hasResultContext","entitySet","annotations","Common","ResultContext","valueOf","processEntitySetFilterRestrictions","restrictions","hasResultContextValue","filterRestictions","processPropertyPathFilterRestrictions","navPrefix","reqSubset","slice","length","nonFilterSubset","parentAllowedExpressions","Object","keys","outProp","outPropPath","mergeObjects","processNavigationFilterRestrictions","navigationRestrictions","uniqueSort","concat","processNavigationAssociationFilterRestrictions","associationRestrictions","processFilterRestrictionsFromConverter","dataModelObjectPath","isContainment","isEntitySet","targetEntitySet","containmentNavPath","navigationProperties","name","entitySetFilterRestrictions","Capabilities","FilterRestrictions","parentFilterRestrictions","startingEntitySet","navigationPathParts","prop","NavigationRestrictions","RestrictedProperties","find","navProp","navPropPath","NavigationProperty","isPartialPathMatch","some","_","index","partialPath","join","fullPath","navFilterRestrictions","navigationAssociation","associationFilterRestrictions","getFilterRestrictionsByDataModel"],"sourceRoot":".","sources":["FilterRestrictions.ts"],"sourcesContent":["import type { EntitySet, PropertyPath } from \"@sap-ux/vocabularies-types\";\nimport type { FilterRestrictionsType } from \"@sap-ux/vocabularies-types/vocabularies/Capabilities\";\nimport type { EntitySetAnnotations_Capabilities } from \"@sap-ux/vocabularies-types/vocabularies/Capabilities_Edm\";\nimport uniqueSort from \"sap/base/util/array/uniqueSort\";\nimport mergeObjects from \"sap/base/util/merge\";\nimport type { PageContextPathTarget } from \"sap/fe/core/converters/TemplateConverter\";\nimport { isEntitySet } from \"sap/fe/core/helpers/TypeGuards\";\nimport type { DataModelObjectPath } from \"sap/fe/core/templating/DataModelPathHelper\";\n\ntype _FilterAllowedExpressions = Record<string, string[]>;\n\nexport type FilterRestrictions = {\n\tRequiredProperties: string[];\n\tNonFilterableProperties: string[];\n\tFilterAllowedExpressions: _FilterAllowedExpressions;\n};\n\ntype FilterExpressionRestriction = {\n\tProperty?: PropertyPath;\n\tAllowedExpressions?: string;\n};\n\n/**\n * Extracts property path string from a flexible path object used in converter or annotation inputs.\n * The object may contain a 'value' field. Returns undefined if it is a non-empty string.\n * @param ref Potential property reference object.\n * @returns Property path string or undefined.\n */\nfunction extractPath(ref: PropertyPath | undefined): string | undefined {\n\tif (!ref) {\n\t\treturn undefined;\n\t}\n\treturn typeof ref.value === \"string\" ? ref.value : undefined;\n}\n\n/**\n * Parses raw FilterRestrictionsType annotation into plain arrays of strings and a mapping of allowed expressions.\n * This replaces previous two-step normalization + extraction logic and deliberately avoids introducing $PropertyPath objects.\n * @param filterRestrictions Raw filter restrictions annotation (may be undefined).\n * @returns Parsed filter restrictions with simple string collections.\n */\nfunction getFilterRestrictions(filterRestrictions: FilterRestrictionsType | undefined): FilterRestrictions {\n\tif (!filterRestrictions) {\n\t\treturn { RequiredProperties: [], NonFilterableProperties: [], FilterAllowedExpressions: {} };\n\t}\n\n\tconst required: string[] = (filterRestrictions.RequiredProperties ?? []).map((p) => extractPath(p)).filter((p): p is string => !!p);\n\tconst nonFilterable: string[] = (filterRestrictions.NonFilterableProperties ?? [])\n\t\t.map((p) => extractPath(p))\n\t\t.filter((p): p is string => !!p);\n\n\tconst allowed: _FilterAllowedExpressions = {};\n\tfor (const expr of filterRestrictions.FilterExpressionRestrictions ?? []) {\n\t\tconst exprObj = expr as FilterExpressionRestriction;\n\t\tconst propPath = extractPath(exprObj.Property);\n\t\tconst allowedExp = typeof exprObj.AllowedExpressions === \"string\" ? exprObj.AllowedExpressions : undefined;\n\t\tif (!propPath || !allowedExp) {\n\t\t\tcontinue;\n\t\t}\n\t\tif (allowed[propPath] !== undefined) {\n\t\t\tallowed[propPath].push(allowedExp);\n\t\t} else {\n\t\t\tallowed[propPath] = [allowedExp];\n\t\t}\n\t}\n\n\treturn {\n\t\tRequiredProperties: required,\n\t\tNonFilterableProperties: nonFilterable,\n\t\tFilterAllowedExpressions: allowed\n\t};\n}\n\nfunction _fetchPropertiesForNavPath(paths: string[], navPath: string, props: string[]): string[] {\n\tconst navPathPrefix = navPath + \"/\";\n\treturn paths.reduce((outPaths: string[], pathToCheck: string) => {\n\t\tif (pathToCheck.startsWith(navPathPrefix)) {\n\t\t\tconst outPath = pathToCheck.replace(navPathPrefix, \"\");\n\t\t\tif (!outPaths.includes(outPath)) {\n\t\t\t\toutPaths.push(outPath);\n\t\t\t}\n\t\t}\n\t\treturn outPaths;\n\t}, props);\n}\n\n/**\n * Initializes an empty filter restrictions object with default values.\n * @returns The initialized filter restrictions object\n */\nfunction initializeFilterRestrictions(): FilterRestrictions {\n\treturn {\n\t\tRequiredProperties: [],\n\t\tNonFilterableProperties: [],\n\t\tFilterAllowedExpressions: {}\n\t};\n}\n\n/**\n * Determines if the entity set has a result context annotation.\n * @param entitySet The entity set to check\n * @returns True if the entity set has result context, false otherwise\n */\nfunction hasResultContext(entitySet: EntitySet | null | undefined): boolean {\n\tif (!entitySet?.annotations?.Common) {\n\t\treturn false;\n\t}\n\treturn \"ResultContext\" in entitySet.annotations.Common ? entitySet.annotations.Common.ResultContext?.valueOf() === true : false;\n}\n\n/**\n * Processes filter restrictions at entity set level (least priority).\n * @param restrictions The current filter restrictions object\n * @param filterRestrictions The filter restrictions annotation\n * @param hasResultContextValue Whether the entity has result context\n * @returns Updated filter restrictions object\n */\nfunction processEntitySetFilterRestrictions(\n\trestrictions: FilterRestrictions,\n\tfilterRestrictions: FilterRestrictionsType | undefined,\n\thasResultContextValue: boolean\n): FilterRestrictions {\n\tconst filterRestictions = getFilterRestrictions(filterRestrictions);\n\trestrictions.RequiredProperties = filterRestictions.RequiredProperties;\n\tif (!hasResultContextValue) {\n\t\trestrictions.NonFilterableProperties = filterRestictions.NonFilterableProperties;\n\t}\n\trestrictions.FilterAllowedExpressions = filterRestictions.FilterAllowedExpressions;\n\treturn restrictions;\n}\n\n/**\n * Processes property path filter restrictions (third highest priority).\n * @param restrictions The current filter restrictions object\n * @param filterRestrictions The parent filter restrictions\n * @param navPath The navigation path\n * @returns Updated filter restrictions object\n */\nfunction processPropertyPathFilterRestrictions(\n\trestrictions: FilterRestrictions,\n\tfilterRestrictions: FilterRestrictionsType | undefined,\n\tnavPath: string\n): FilterRestrictions {\n\tif (!filterRestrictions || navPath.includes(\"%2F\")) {\n\t\treturn restrictions;\n\t}\n\tconst filterRestictions = getFilterRestrictions(filterRestrictions);\n\n\tconst navPrefix = navPath + \"/\";\n\tconst reqSubset = filterRestictions.RequiredProperties.filter((p) => p.startsWith(navPrefix)).map((p) => p.slice(navPrefix.length));\n\tconst nonFilterSubset = filterRestictions.NonFilterableProperties.filter((p) => p.startsWith(navPrefix)).map((p) =>\n\t\tp.slice(navPrefix.length)\n\t);\n\trestrictions.RequiredProperties = _fetchPropertiesForNavPath(reqSubset, navPath, restrictions.RequiredProperties);\n\trestrictions.NonFilterableProperties = _fetchPropertiesForNavPath(nonFilterSubset, navPath, restrictions.NonFilterableProperties);\n\n\tconst parentAllowedExpressions = Object.keys(filterRestictions.FilterAllowedExpressions).reduce(\n\t\t(outProp: Record<string, string[]>, propPath: string) => {\n\t\t\tif (propPath.startsWith(navPrefix)) {\n\t\t\t\tconst outPropPath = propPath.slice(navPrefix.length);\n\t\t\t\toutProp[outPropPath] = filterRestictions.FilterAllowedExpressions[propPath];\n\t\t\t}\n\t\t\treturn outProp;\n\t\t},\n\t\t{} as Record<string, string[]>\n\t);\n\n\trestrictions.FilterAllowedExpressions = mergeObjects({}, restrictions.FilterAllowedExpressions, parentAllowedExpressions) as Record<\n\t\tstring,\n\t\tstring[]\n\t>;\n\treturn restrictions;\n}\n\n/**\n * Processes navigation restrictions (second highest priority).\n * @param restrictions The current filter restrictions object\n * @param navigationRestrictions The navigation restrictions\n * @returns Updated filter restrictions object\n */\nfunction processNavigationFilterRestrictions(\n\trestrictions: FilterRestrictions,\n\tnavigationRestrictions: FilterRestrictionsType | undefined\n): FilterRestrictions {\n\tconst filterRestictions = getFilterRestrictions(navigationRestrictions);\n\trestrictions.RequiredProperties = uniqueSort(restrictions.RequiredProperties.concat(filterRestictions.RequiredProperties));\n\trestrictions.NonFilterableProperties = uniqueSort(\n\t\trestrictions.NonFilterableProperties.concat(filterRestictions.NonFilterableProperties)\n\t);\n\trestrictions.FilterAllowedExpressions = mergeObjects(\n\t\t{},\n\t\trestrictions.FilterAllowedExpressions,\n\t\tfilterRestictions.FilterAllowedExpressions\n\t) as Record<string, string[]>;\n\treturn restrictions;\n}\n\n/**\n * Processes navigation association entity restrictions (highest priority).\n * @param restrictions The current filter restrictions object\n * @param associationRestrictions The association entity filter restrictions\n * @returns Updated filter restrictions object\n */\nfunction processNavigationAssociationFilterRestrictions(\n\trestrictions: FilterRestrictions,\n\tassociationRestrictions: FilterRestrictionsType | undefined\n): FilterRestrictions {\n\tconst filterRestictions = getFilterRestrictions(associationRestrictions);\n\trestrictions.RequiredProperties = uniqueSort(restrictions.RequiredProperties.concat(filterRestictions.RequiredProperties));\n\trestrictions.NonFilterableProperties = uniqueSort(\n\t\trestrictions.NonFilterableProperties.concat(filterRestictions.NonFilterableProperties)\n\t);\n\trestrictions.FilterAllowedExpressions = mergeObjects(\n\t\t{},\n\t\trestrictions.FilterAllowedExpressions,\n\t\tfilterRestictions.FilterAllowedExpressions\n\t) as _FilterAllowedExpressions;\n\treturn restrictions;\n}\n\n/**\n * Processes filter restrictions using converter context.\n * @param dataModelObjectPath The data model object path\n * @returns Processed filter restrictions\n */\nfunction processFilterRestrictionsFromConverter(dataModelObjectPath: DataModelObjectPath<PageContextPathTarget>): FilterRestrictions {\n\tconst restrictions = initializeFilterRestrictions();\n\tconst isContainment = !isEntitySet(dataModelObjectPath.targetEntitySet);\n\tconst containmentNavPath =\n\t\tisContainment && dataModelObjectPath.navigationProperties[dataModelObjectPath.navigationProperties.length - 1]?.name;\n\n\t// LEAST PRIORITY - Filter restrictions directly at Entity Set\n\tif (!isContainment) {\n\t\tconst entitySetFilterRestrictions = (\n\t\t\tdataModelObjectPath.targetEntitySet?.annotations?.Capabilities as EntitySetAnnotations_Capabilities\n\t\t)?.FilterRestrictions;\n\t\tconst hasResultContextValue = hasResultContext(dataModelObjectPath.targetEntitySet as EntitySet | null | undefined);\n\n\t\tprocessEntitySetFilterRestrictions(restrictions, entitySetFilterRestrictions, hasResultContextValue);\n\t}\n\n\tif (dataModelObjectPath.navigationProperties.length > 0) {\n\t\tconst navPath = isContainment\n\t\t\t? (containmentNavPath as string)\n\t\t\t: dataModelObjectPath.navigationProperties[dataModelObjectPath.navigationProperties.length - 1]?.name;\n\n\t\t// THIRD HIGHEST PRIORITY - Property path restrictions at parent entity\n\t\tconst parentFilterRestrictions = (\n\t\t\tdataModelObjectPath.startingEntitySet?.annotations?.Capabilities as EntitySetAnnotations_Capabilities\n\t\t)?.FilterRestrictions;\n\t\tprocessPropertyPathFilterRestrictions(restrictions, parentFilterRestrictions, navPath);\n\n\t\t// SECOND HIGHEST PRIORITY - Navigation restrictions from parent entity set\n\t\t// Build the full navigation path dynamically\n\t\tconst navigationPathParts = dataModelObjectPath.navigationProperties.map((prop) => prop.name);\n\n\t\t// Check for navigation restrictions that match any part of our navigation path\n\t\tconst navigationRestrictions =\n\t\t\tdataModelObjectPath.startingEntitySet?.annotations?.Capabilities?.NavigationRestrictions?.RestrictedProperties?.find(\n\t\t\t\t(navProp) => {\n\t\t\t\t\tconst navPropPath = navProp.NavigationProperty.value;\n\t\t\t\t\tif (!navPropPath) {\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Check if the navigation property path matches any of our navigation segments\n\t\t\t\t\t// This handles both single level (e.g., \"_PartnerItems\") and multi-level (e.g., \"Set/_PartnerItems\") paths\n\t\t\t\t\tconst isPartialPathMatch = navigationPathParts.some((_, index) => {\n\t\t\t\t\t\tconst partialPath = navigationPathParts.slice(index).join(\"/\");\n\t\t\t\t\t\treturn navPropPath === partialPath;\n\t\t\t\t\t});\n\n\t\t\t\t\t// Also check the full path\n\t\t\t\t\tconst fullPath = navigationPathParts.join(\"/\");\n\t\t\t\t\treturn isPartialPathMatch || navPropPath === fullPath;\n\t\t\t\t}\n\t\t\t);\n\n\t\tconst navFilterRestrictions = navigationRestrictions?.FilterRestrictions;\n\t\tprocessNavigationFilterRestrictions(restrictions, navFilterRestrictions);\n\n\t\t// HIGHEST PRIORITY - Navigation association entity restrictions\n\t\tconst navigationAssociation = dataModelObjectPath.navigationProperties.find((navProp) => navProp.name === navPath);\n\t\tconst associationFilterRestrictions = (navigationAssociation?.annotations?.Capabilities as EntitySetAnnotations_Capabilities)\n\t\t\t?.FilterRestrictions;\n\t\tprocessNavigationAssociationFilterRestrictions(restrictions, associationFilterRestrictions);\n\t}\n\n\treturn restrictions;\n}\n\n/*** Fetches filter restrictions by entity path with proper priority handling and ensures correct processing order by following priority order:\n * 1. LEAST PRIORITY: Filter restrictions directly at Entity Set\n * 2. THIRD HIGHEST PRIORITY: Property path restrictions at parent entity\n * 3. SECOND HIGHEST PRIORITY: Navigation restrictions\n * 4. HIGHEST PRIORITY: Restrictions at navigation association entity\n * @param converterContext Optional converter context for enhanced processing\n * @returns Filter restrictions object containing required properties, non-filterable properties, and allowed expressions\n */\nfunction getFilterRestrictionsByDataModel(dataModelObjectPath?: DataModelObjectPath<PageContextPathTarget>): FilterRestrictions {\n\tif (dataModelObjectPath) {\n\t\treturn processFilterRestrictionsFromConverter(dataModelObjectPath);\n\t}\n\treturn initializeFilterRestrictions();\n}\n\nconst FilterRestrictions = { getFilterRestrictionsByDataModel };\n\nexport default FilterRestrictions;\n"],"mappings":"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","ignoreList":[]}

package/src/sap/fe/core/converters/controls/Common/filter/FilterRestrictions.ts

@@ -0,0 +1,309 @@
+import type { EntitySet, PropertyPath } from "@sap-ux/vocabularies-types";
+import type { FilterRestrictionsType } from "@sap-ux/vocabularies-types/vocabularies/Capabilities";
+import type { EntitySetAnnotations_Capabilities } from "@sap-ux/vocabularies-types/vocabularies/Capabilities_Edm";
+import uniqueSort from "sap/base/util/array/uniqueSort";
+import mergeObjects from "sap/base/util/merge";
+import type { PageContextPathTarget } from "sap/fe/core/converters/TemplateConverter";
+import { isEntitySet } from "sap/fe/core/helpers/TypeGuards";
+import type { DataModelObjectPath } from "sap/fe/core/templating/DataModelPathHelper";
+
+type _FilterAllowedExpressions = Record<string, string[]>;
+
+export type FilterRestrictions = {
+	RequiredProperties: string[];
+	NonFilterableProperties: string[];
+	FilterAllowedExpressions: _FilterAllowedExpressions;
+};
+
+type FilterExpressionRestriction = {
+	Property?: PropertyPath;
+	AllowedExpressions?: string;
+};
+
+/**
+ * Extracts property path string from a flexible path object used in converter or annotation inputs.
+ * The object may contain a 'value' field. Returns undefined if it is a non-empty string.
+ * @param ref Potential property reference object.
+ * @returns Property path string or undefined.
+ */
+function extractPath(ref: PropertyPath | undefined): string | undefined {
+	if (!ref) {
+		return undefined;
+	}
+	return typeof ref.value === "string" ? ref.value : undefined;
+}
+
+/**
+ * Parses raw FilterRestrictionsType annotation into plain arrays of strings and a mapping of allowed expressions.
+ * This replaces previous two-step normalization + extraction logic and deliberately avoids introducing $PropertyPath objects.
+ * @param filterRestrictions Raw filter restrictions annotation (may be undefined).
+ * @returns Parsed filter restrictions with simple string collections.
+ */
+function getFilterRestrictions(filterRestrictions: FilterRestrictionsType | undefined): FilterRestrictions {
+	if (!filterRestrictions) {
+		return { RequiredProperties: [], NonFilterableProperties: [], FilterAllowedExpressions: {} };
+	}
+
+	const required: string[] = (filterRestrictions.RequiredProperties ?? []).map((p) => extractPath(p)).filter((p): p is string => !!p);
+	const nonFilterable: string[] = (filterRestrictions.NonFilterableProperties ?? [])
+		.map((p) => extractPath(p))
+		.filter((p): p is string => !!p);
+
+	const allowed: _FilterAllowedExpressions = {};
+	for (const expr of filterRestrictions.FilterExpressionRestrictions ?? []) {
+		const exprObj = expr as FilterExpressionRestriction;
+		const propPath = extractPath(exprObj.Property);
+		const allowedExp = typeof exprObj.AllowedExpressions === "string" ? exprObj.AllowedExpressions : undefined;
+		if (!propPath || !allowedExp) {
+			continue;
+		}
+		if (allowed[propPath] !== undefined) {
+			allowed[propPath].push(allowedExp);
+		} else {
+			allowed[propPath] = [allowedExp];
+		}
+	}
+
+	return {
+		RequiredProperties: required,
+		NonFilterableProperties: nonFilterable,
+		FilterAllowedExpressions: allowed
+	};
+}
+
+function _fetchPropertiesForNavPath(paths: string[], navPath: string, props: string[]): string[] {
+	const navPathPrefix = navPath + "/";
+	return paths.reduce((outPaths: string[], pathToCheck: string) => {
+		if (pathToCheck.startsWith(navPathPrefix)) {
+			const outPath = pathToCheck.replace(navPathPrefix, "");
+			if (!outPaths.includes(outPath)) {
+				outPaths.push(outPath);
+			}
+		}
+		return outPaths;
+	}, props);
+}
+
+/**
+ * Initializes an empty filter restrictions object with default values.
+ * @returns The initialized filter restrictions object
+ */
+function initializeFilterRestrictions(): FilterRestrictions {
+	return {
+		RequiredProperties: [],
+		NonFilterableProperties: [],
+		FilterAllowedExpressions: {}
+	};
+}
+
+/**
+ * Determines if the entity set has a result context annotation.
+ * @param entitySet The entity set to check
+ * @returns True if the entity set has result context, false otherwise
+ */
+function hasResultContext(entitySet: EntitySet | null | undefined): boolean {
+	if (!entitySet?.annotations?.Common) {
+		return false;
+	}
+	return "ResultContext" in entitySet.annotations.Common ? entitySet.annotations.Common.ResultContext?.valueOf() === true : false;
+}
+
+/**
+ * Processes filter restrictions at entity set level (least priority).
+ * @param restrictions The current filter restrictions object
+ * @param filterRestrictions The filter restrictions annotation
+ * @param hasResultContextValue Whether the entity has result context
+ * @returns Updated filter restrictions object
+ */
+function processEntitySetFilterRestrictions(
+	restrictions: FilterRestrictions,
+	filterRestrictions: FilterRestrictionsType | undefined,
+	hasResultContextValue: boolean
+): FilterRestrictions {
+	const filterRestictions = getFilterRestrictions(filterRestrictions);
+	restrictions.RequiredProperties = filterRestictions.RequiredProperties;
+	if (!hasResultContextValue) {
+		restrictions.NonFilterableProperties = filterRestictions.NonFilterableProperties;
+	}
+	restrictions.FilterAllowedExpressions = filterRestictions.FilterAllowedExpressions;
+	return restrictions;
+}
+
+/**
+ * Processes property path filter restrictions (third highest priority).
+ * @param restrictions The current filter restrictions object
+ * @param filterRestrictions The parent filter restrictions
+ * @param navPath The navigation path
+ * @returns Updated filter restrictions object
+ */
+function processPropertyPathFilterRestrictions(
+	restrictions: FilterRestrictions,
+	filterRestrictions: FilterRestrictionsType | undefined,
+	navPath: string
+): FilterRestrictions {
+	if (!filterRestrictions || navPath.includes("%2F")) {
+		return restrictions;
+	}
+	const filterRestictions = getFilterRestrictions(filterRestrictions);
+
+	const navPrefix = navPath + "/";
+	const reqSubset = filterRestictions.RequiredProperties.filter((p) => p.startsWith(navPrefix)).map((p) => p.slice(navPrefix.length));
+	const nonFilterSubset = filterRestictions.NonFilterableProperties.filter((p) => p.startsWith(navPrefix)).map((p) =>
+		p.slice(navPrefix.length)
+	);
+	restrictions.RequiredProperties = _fetchPropertiesForNavPath(reqSubset, navPath, restrictions.RequiredProperties);
+	restrictions.NonFilterableProperties = _fetchPropertiesForNavPath(nonFilterSubset, navPath, restrictions.NonFilterableProperties);
+
+	const parentAllowedExpressions = Object.keys(filterRestictions.FilterAllowedExpressions).reduce(
+		(outProp: Record<string, string[]>, propPath: string) => {
+			if (propPath.startsWith(navPrefix)) {
+				const outPropPath = propPath.slice(navPrefix.length);
+				outProp[outPropPath] = filterRestictions.FilterAllowedExpressions[propPath];
+			}
+			return outProp;
+		},
+		{} as Record<string, string[]>
+	);
+
+	restrictions.FilterAllowedExpressions = mergeObjects({}, restrictions.FilterAllowedExpressions, parentAllowedExpressions) as Record<
+		string,
+		string[]
+	>;
+	return restrictions;
+}
+
+/**
+ * Processes navigation restrictions (second highest priority).
+ * @param restrictions The current filter restrictions object
+ * @param navigationRestrictions The navigation restrictions
+ * @returns Updated filter restrictions object
+ */
+function processNavigationFilterRestrictions(
+	restrictions: FilterRestrictions,
+	navigationRestrictions: FilterRestrictionsType | undefined
+): FilterRestrictions {
+	const filterRestictions = getFilterRestrictions(navigationRestrictions);
+	restrictions.RequiredProperties = uniqueSort(restrictions.RequiredProperties.concat(filterRestictions.RequiredProperties));
+	restrictions.NonFilterableProperties = uniqueSort(
+		restrictions.NonFilterableProperties.concat(filterRestictions.NonFilterableProperties)
+	);
+	restrictions.FilterAllowedExpressions = mergeObjects(
+		{},
+		restrictions.FilterAllowedExpressions,
+		filterRestictions.FilterAllowedExpressions
+	) as Record<string, string[]>;
+	return restrictions;
+}
+
+/**
+ * Processes navigation association entity restrictions (highest priority).
+ * @param restrictions The current filter restrictions object
+ * @param associationRestrictions The association entity filter restrictions
+ * @returns Updated filter restrictions object
+ */
+function processNavigationAssociationFilterRestrictions(
+	restrictions: FilterRestrictions,
+	associationRestrictions: FilterRestrictionsType | undefined
+): FilterRestrictions {
+	const filterRestictions = getFilterRestrictions(associationRestrictions);
+	restrictions.RequiredProperties = uniqueSort(restrictions.RequiredProperties.concat(filterRestictions.RequiredProperties));
+	restrictions.NonFilterableProperties = uniqueSort(
+		restrictions.NonFilterableProperties.concat(filterRestictions.NonFilterableProperties)
+	);
+	restrictions.FilterAllowedExpressions = mergeObjects(
+		{},
+		restrictions.FilterAllowedExpressions,
+		filterRestictions.FilterAllowedExpressions
+	) as _FilterAllowedExpressions;
+	return restrictions;
+}
+
+/**
+ * Processes filter restrictions using converter context.
+ * @param dataModelObjectPath The data model object path
+ * @returns Processed filter restrictions
+ */
+function processFilterRestrictionsFromConverter(dataModelObjectPath: DataModelObjectPath<PageContextPathTarget>): FilterRestrictions {
+	const restrictions = initializeFilterRestrictions();
+	const isContainment = !isEntitySet(dataModelObjectPath.targetEntitySet);
+	const containmentNavPath =
+		isContainment && dataModelObjectPath.navigationProperties[dataModelObjectPath.navigationProperties.length - 1]?.name;
+
+	// LEAST PRIORITY - Filter restrictions directly at Entity Set
+	if (!isContainment) {
+		const entitySetFilterRestrictions = (
+			dataModelObjectPath.targetEntitySet?.annotations?.Capabilities as EntitySetAnnotations_Capabilities
+		)?.FilterRestrictions;
+		const hasResultContextValue = hasResultContext(dataModelObjectPath.targetEntitySet as EntitySet | null | undefined);
+
+		processEntitySetFilterRestrictions(restrictions, entitySetFilterRestrictions, hasResultContextValue);
+	}
+
+	if (dataModelObjectPath.navigationProperties.length > 0) {
+		const navPath = isContainment
+			? (containmentNavPath as string)
+			: dataModelObjectPath.navigationProperties[dataModelObjectPath.navigationProperties.length - 1]?.name;
+
+		// THIRD HIGHEST PRIORITY - Property path restrictions at parent entity
+		const parentFilterRestrictions = (
+			dataModelObjectPath.startingEntitySet?.annotations?.Capabilities as EntitySetAnnotations_Capabilities
+		)?.FilterRestrictions;
+		processPropertyPathFilterRestrictions(restrictions, parentFilterRestrictions, navPath);
+
+		// SECOND HIGHEST PRIORITY - Navigation restrictions from parent entity set
+		// Build the full navigation path dynamically
+		const navigationPathParts = dataModelObjectPath.navigationProperties.map((prop) => prop.name);
+
+		// Check for navigation restrictions that match any part of our navigation path
+		const navigationRestrictions =
+			dataModelObjectPath.startingEntitySet?.annotations?.Capabilities?.NavigationRestrictions?.RestrictedProperties?.find(
+				(navProp) => {
+					const navPropPath = navProp.NavigationProperty.value;
+					if (!navPropPath) {
+						return false;
+					}
+
+					// Check if the navigation property path matches any of our navigation segments
+					// This handles both single level (e.g., "_PartnerItems") and multi-level (e.g., "Set/_PartnerItems") paths
+					const isPartialPathMatch = navigationPathParts.some((_, index) => {
+						const partialPath = navigationPathParts.slice(index).join("/");
+						return navPropPath === partialPath;
+					});
+
+					// Also check the full path
+					const fullPath = navigationPathParts.join("/");
+					return isPartialPathMatch || navPropPath === fullPath;
+				}
+			);
+
+		const navFilterRestrictions = navigationRestrictions?.FilterRestrictions;
+		processNavigationFilterRestrictions(restrictions, navFilterRestrictions);
+
+		// HIGHEST PRIORITY - Navigation association entity restrictions
+		const navigationAssociation = dataModelObjectPath.navigationProperties.find((navProp) => navProp.name === navPath);
+		const associationFilterRestrictions = (navigationAssociation?.annotations?.Capabilities as EntitySetAnnotations_Capabilities)
+			?.FilterRestrictions;
+		processNavigationAssociationFilterRestrictions(restrictions, associationFilterRestrictions);
+	}
+
+	return restrictions;
+}
+
+/*** Fetches filter restrictions by entity path with proper priority handling and ensures correct processing order by following priority order:
+ * 1. LEAST PRIORITY: Filter restrictions directly at Entity Set
+ * 2. THIRD HIGHEST PRIORITY: Property path restrictions at parent entity
+ * 3. SECOND HIGHEST PRIORITY: Navigation restrictions
+ * 4. HIGHEST PRIORITY: Restrictions at navigation association entity
+ * @param converterContext Optional converter context for enhanced processing
+ * @returns Filter restrictions object containing required properties, non-filterable properties, and allowed expressions
+ */
+function getFilterRestrictionsByDataModel(dataModelObjectPath?: DataModelObjectPath<PageContextPathTarget>): FilterRestrictions {
+	if (dataModelObjectPath) {
+		return processFilterRestrictionsFromConverter(dataModelObjectPath);
+	}
+	return initializeFilterRestrictions();
+}
+
+const FilterRestrictions = { getFilterRestrictionsByDataModel };
+
+export default FilterRestrictions;