feat(toolbar): Export extractUniqueFieldNamesFromFilterTree as public static method on ExpressionsTreeUtil

Co-authored-by: ivanvpetrov <110455887+ivanvpetrov@users.noreply.github.com>
Agent-Logs-Url: https://github.com/IgniteUI/igniteui-angular/sessions/cde76442-6a72-430d-91f9-44544e3364f2

Author: Copilot

projects/igniteui-angular/core/src/data-operations/expressions-tree-util.spec.ts

@@ -1,6 +1,6 @@
 import { FilteringLogic, IFilteringExpression } from './filtering-expression.interface';
 import { FilteringExpressionsTree, IFilteringExpressionsTree } from './filtering-expressions-tree';
-import { recreateExpression, recreateTree, recreateTreeFromFields } from './expressions-tree-util';
+import { ExpressionsTreeUtil, recreateExpression, recreateTree, recreateTreeFromFields } from './expressions-tree-util';
 import { IgxBooleanFilteringOperand, IgxDateFilteringOperand, IgxDateTimeFilteringOperand, IgxNumberFilteringOperand, IgxStringFilteringOperand, IgxTimeFilteringOperand } from './filtering-condition';
 import type { EntityType, FieldType } from './grid-types';
 
@@ -479,3 +479,61 @@ describe('Unit testing FilteringUtil', () => {
     });
 
 });
+
+describe('ExpressionsTreeUtil.extractUniqueFieldNamesFromFilterTree', () => {
+    it('Should return an empty array for undefined input', () => {
+        const result = ExpressionsTreeUtil.extractUniqueFieldNamesFromFilterTree(undefined);
+        expect(result).toEqual([]);
+    });
+
+    it('Should return an empty array for a tree with no operands', () => {
+        const tree = new FilteringExpressionsTree(FilteringLogic.And);
+        const result = ExpressionsTreeUtil.extractUniqueFieldNamesFromFilterTree(tree);
+        expect(result).toEqual([]);
+    });
+
+    it('Should return unique field names from a flat filtering tree', () => {
+        const tree = new FilteringExpressionsTree(FilteringLogic.And);
+        tree.filteringOperands.push({ fieldName: 'ProductName', conditionName: 'contains', searchVal: 'A' } as IFilteringExpression);
+        tree.filteringOperands.push({ fieldName: 'Downloads', conditionName: 'greaterThan', searchVal: 100 } as IFilteringExpression);
+        tree.filteringOperands.push({ fieldName: 'ProductName', conditionName: 'startsWith', searchVal: 'B' } as IFilteringExpression);
+
+        const result = ExpressionsTreeUtil.extractUniqueFieldNamesFromFilterTree(tree);
+        expect(result.length).toBe(2);
+        expect(result).toContain('ProductName');
+        expect(result).toContain('Downloads');
+    });
+
+    it('Should return unique field names from a nested filtering tree', () => {
+        const outerTree = new FilteringExpressionsTree(FilteringLogic.Or);
+        const innerTree = new FilteringExpressionsTree(FilteringLogic.And);
+
+        outerTree.filteringOperands.push({ fieldName: 'ID', conditionName: 'equals', searchVal: 1 } as IFilteringExpression);
+        innerTree.filteringOperands.push({ fieldName: 'ProductName', conditionName: 'contains', searchVal: 'test' } as IFilteringExpression);
+        innerTree.filteringOperands.push({ fieldName: 'ID', conditionName: 'lessThan', searchVal: 50 } as IFilteringExpression);
+        outerTree.filteringOperands.push(innerTree);
+
+        const result = ExpressionsTreeUtil.extractUniqueFieldNamesFromFilterTree(outerTree);
+        expect(result.length).toBe(2);
+        expect(result).toContain('ID');
+        expect(result).toContain('ProductName');
+    });
+
+    it('Should return unique field names from a deeply nested filtering tree', () => {
+        const root = new FilteringExpressionsTree(FilteringLogic.And);
+        const level1 = new FilteringExpressionsTree(FilteringLogic.Or);
+        const level2 = new FilteringExpressionsTree(FilteringLogic.And);
+
+        level2.filteringOperands.push({ fieldName: 'Downloads', conditionName: 'greaterThan', searchVal: 10 } as IFilteringExpression);
+        level1.filteringOperands.push({ fieldName: 'ProductName', conditionName: 'contains', searchVal: 'x' } as IFilteringExpression);
+        level1.filteringOperands.push(level2);
+        root.filteringOperands.push({ fieldName: 'ID', conditionName: 'equals', searchVal: 5 } as IFilteringExpression);
+        root.filteringOperands.push(level1);
+
+        const result = ExpressionsTreeUtil.extractUniqueFieldNamesFromFilterTree(root);
+        expect(result.length).toBe(3);
+        expect(result).toContain('ID');
+        expect(result).toContain('ProductName');
+        expect(result).toContain('Downloads');
+    });
+});

projects/igniteui-angular/core/src/data-operations/expressions-tree-util.ts

@@ -6,6 +6,28 @@ import { IExpressionTree, IFilteringExpressionsTree } from './filtering-expressi
 import { DateTimeUtil } from '../date-common/public_api';
 
 export class ExpressionsTreeUtil {
+    /**
+     * Returns the unique field names from the provided filtering expressions tree.
+     * Useful for calculating the number of columns that have advanced filters applied.
+     * ```typescript
+     * let fieldNames = ExpressionsTreeUtil.extractUniqueFieldNamesFromFilterTree(gridExpressionTree);
+     * ```
+     * @param filteringTree The filtering expressions tree to extract field names from.
+     * @returns An array of unique field names referenced in the filtering tree.
+     */
+    public static extractUniqueFieldNamesFromFilterTree(filteringTree?: IFilteringExpressionsTree): string[] {
+        const columnNames: string[] = [];
+        if (!filteringTree) return columnNames;
+        filteringTree.filteringOperands.forEach((expr) => {
+            if (isTree(expr)) {
+                columnNames.push(...this.extractUniqueFieldNamesFromFilterTree(expr as IFilteringExpressionsTree));
+            } else {
+                columnNames.push((expr as IFilteringExpression).fieldName);
+            }
+        });
+        return [...new Set(columnNames)];
+    }
+
     /**
      * Returns the filtering expression for a column with the provided tree and fieldName.
      * ```typescript

projects/igniteui-angular/grids/core/src/toolbar/grid-toolbar-advanced-filtering.component.ts

@@ -2,7 +2,7 @@ import { Component, Input, OnInit, inject } from '@angular/core';
 import { IgxToolbarToken } from './token';
 import { IgxButtonDirective, IgxRippleDirective } from 'igniteui-angular/directives';
 import { IgxIconComponent } from 'igniteui-angular/icon';
-import { IFilteringExpressionsTree, isTree, OverlaySettings } from 'igniteui-angular/core';
+import { ExpressionsTreeUtil, IFilteringExpressionsTree, OverlaySettings } from 'igniteui-angular/core';
 
 /* blazorElement */
 /* wcElementTag: igc-grid-toolbar-advanced-filtering */
@@ -48,24 +48,11 @@ export class IgxGridToolbarAdvancedFilteringComponent implements OnInit {
      */
     public ngOnInit(): void {
         // Initial value
-        this.numberOfColumns = this.grid?.advancedFilteringExpressionsTree ? this.extractUniqueFieldNamesFromFilterTree(this.grid?.advancedFilteringExpressionsTree).length : 0;
+        this.numberOfColumns = this.grid?.advancedFilteringExpressionsTree ? ExpressionsTreeUtil.extractUniqueFieldNamesFromFilterTree(this.grid?.advancedFilteringExpressionsTree).length : 0;
 
         // Subscribing for future updates
         this.grid?.advancedFilteringExpressionsTreeChange.subscribe(filteringTree => {
-            this.numberOfColumns = this.extractUniqueFieldNamesFromFilterTree(filteringTree).length;
+            this.numberOfColumns = ExpressionsTreeUtil.extractUniqueFieldNamesFromFilterTree(filteringTree).length;
         });
     }
-
-    protected extractUniqueFieldNamesFromFilterTree(filteringTree?: IFilteringExpressionsTree) : string[] {
-        const columnNames = [];
-        if (!filteringTree) return columnNames;
-        filteringTree.filteringOperands.forEach((expr) => {
-            if (isTree(expr)) {
-                columnNames.push(...this.extractUniqueFieldNamesFromFilterTree(expr));
-            } else {
-                columnNames.push(expr.fieldName);
-            }
-        });
-        return [...new Set(columnNames)];
-    }
 }