@open-dcp/grid 0.0.1 → 0.2.17

package/dist/__tests__/GridServices.test.js

@@ -0,0 +1,288 @@
+import { GridService } from '../GridService';
+describe('GridService', () => {
+    let gridService;
+    let mockRows;
+    let mockColumns;
+    beforeEach(() => {
+        // Setup mock columns
+        mockColumns = [
+            { key: 'id', label: 'ID', type: 'integer' },
+            { key: 'name', label: 'Name', type: 'string' },
+            { key: 'age', label: 'Age', type: 'number' },
+        ];
+        // Setup mock rows
+        mockRows = [
+            { id: { raw: 1, value: 1 }, name: { raw: 'Alice', value: 'Alice' }, age: { raw: 30, value: 30 } },
+            { id: { raw: 2, value: 2 }, name: { raw: 'Bob', value: 'Bob' }, age: { raw: 25, value: 25 } },
+            { id: { raw: 3, value: 3 }, name: { raw: 'Charlie', value: 'Charlie' }, age: { raw: 35, value: 35 } },
+        ];
+        gridService = new GridService(mockRows, mockColumns);
+    });
+    it('should initialize with correct row count', () => {
+        expect(gridService.rowCount()).toBe(3);
+    });
+    it('should return all rows', () => {
+        const rows = gridService.getRows();
+        expect(rows.length).toBe(3);
+    });
+    it('should return all columns', () => {
+        const columns = gridService.getColumns();
+        expect(columns.length).toBe(3);
+    });
+    it('should update rows', () => {
+        const newRows = [
+            { id: { raw: 4, value: 4 }, name: { raw: 'David', value: 'David' }, age: { raw: 40, value: 40 } },
+        ];
+        gridService.setRows(newRows);
+        expect(gridService.rowCount()).toBe(1);
+    });
+    it('should toggle sort on a column', () => {
+        gridService.toggleSort('name');
+        const sortCondition = gridService.getSortCondition('name');
+        expect(sortCondition).not.toBeNull();
+        expect(sortCondition === null || sortCondition === void 0 ? void 0 : sortCondition.direction).toBe('asc');
+    });
+    it('should toggle sort direction from asc to desc', () => {
+        gridService.toggleSort('name');
+        gridService.toggleSort('name');
+        const sortCondition = gridService.getSortCondition('name');
+        expect(sortCondition === null || sortCondition === void 0 ? void 0 : sortCondition.direction).toBe('desc');
+    });
+    it('should remove sort after third toggle', () => {
+        gridService.toggleSort('name');
+        gridService.toggleSort('name');
+        gridService.toggleSort('name');
+        const sortCondition = gridService.getSortCondition('name');
+        expect(sortCondition).toBeNull();
+    });
+    it('should sort rows by age ascending', () => {
+        gridService.toggleSort('age');
+        const sortedRows = gridService.getFilteredAndSortRows();
+        expect(sortedRows[0].age.value).toBe(25);
+        expect(sortedRows[1].age.value).toBe(30);
+        expect(sortedRows[2].age.value).toBe(35);
+    });
+    it('should enable API mode', () => {
+        gridService.enableApiMode({ clientSideSort: false, clientSideFilter: false });
+        expect(gridService['apiMode']).toBe(true);
+    });
+    it('should set rows from API', () => {
+        gridService.enableApiMode({ clientSideSort: false, clientSideFilter: false });
+        const apiRows = [
+            { id: { raw: 5, value: 5 }, name: { raw: 'Eve', value: 'Eve' }, age: { raw: 28, value: 28 } },
+        ];
+        gridService.setRowsFromApi(apiRows);
+        expect(gridService.rowCount()).toBe(1);
+    });
+    it('should emit filterSort$ observable when sort is toggled in API mode', (done) => {
+        gridService.enableApiMode({ clientSideSort: false, clientSideFilter: false });
+        gridService.filterSort$.subscribe(({ filterTree, sorts }) => {
+            if (sorts.length > 0) {
+                expect(sorts[0].columnKey).toBe('name');
+                expect(sorts[0].direction).toBe('asc');
+                done();
+            }
+        });
+        gridService.toggleSort('name');
+    });
+    it('should use client-side sorting when enabled in API mode', () => {
+        gridService.enableApiMode({ clientSideSort: true, clientSideFilter: false });
+        gridService.setRowsFromApi(mockRows);
+        gridService.toggleSort('age');
+        const sortedRows = gridService.getFilteredAndSortRows();
+        expect(sortedRows[0].age.value).toBe(25);
+        expect(sortedRows[1].age.value).toBe(30);
+        expect(sortedRows[2].age.value).toBe(35);
+    });
+    it('should select a row', (done) => {
+        gridService.selectRow(0);
+        gridService.getSelected().subscribe(selected => {
+            expect(selected.has(0)).toBe(true);
+            done();
+        });
+    });
+    it('should deselect a row', (done) => {
+        gridService.selectRow(0);
+        gridService.deselectRow(0);
+        gridService.getSelected().subscribe(selected => {
+            expect(selected.has(0)).toBe(false);
+            done();
+        });
+    });
+    it('should toggle row selection', (done) => {
+        gridService.toggleRowSelection(0);
+        gridService.getSelected().subscribe(selected => {
+            expect(selected.has(0)).toBe(true);
+            done();
+        });
+    });
+    it('should clear all selections', (done) => {
+        gridService.selectRow(0);
+        gridService.selectRow(1);
+        gridService.clearSelection();
+        gridService.getSelected().subscribe(selected => {
+            expect(selected.size).toBe(0);
+            done();
+        });
+    });
+    it('should update display format', (done) => {
+        gridService.updateDisplayFormat({ dateFormat: 'dd/MM/yyyy' });
+        gridService.displayFormat$.subscribe(format => {
+            expect(format.dateFormat).toBe('dd/MM/yyyy');
+            done();
+        });
+    });
+    it('should set and clear global search', () => {
+        gridService.setGlobalSearch('Alice');
+        expect(gridService.getGlobalSearch()).toEqual({ query: 'Alice', options: undefined });
+        const searchedRows = gridService.getFilteredRows();
+        expect(searchedRows).toHaveLength(1);
+        expect(searchedRows[0].name.value).toBe('Alice');
+        gridService.clearGlobalSearch();
+        expect(gridService.getGlobalSearch()).toBeNull();
+        expect(gridService.getFilteredRows()).toHaveLength(3);
+    });
+    it('should apply global search only to restricted columns', () => {
+        gridService.setGlobalSearch('25', { columns: ['name'] });
+        expect(gridService.getFilteredRows()).toHaveLength(0);
+        gridService.setGlobalSearch('25', { columns: ['age'] });
+        const searchedRows = gridService.getFilteredRows();
+        expect(searchedRows).toHaveLength(1);
+        expect(searchedRows[0].name.value).toBe('Bob');
+    });
+    it('should apply case-insensitive global search using options', () => {
+        gridService.setGlobalSearch('ALICE', { caseInsensitive: true });
+        const searchedRows = gridService.getFilteredRows();
+        expect(searchedRows).toHaveLength(1);
+        expect(searchedRows[0].name.value).toBe('Alice');
+    });
+    it('should update global search matches after setRows', () => {
+        gridService.setGlobalSearch('zara', { caseInsensitive: true });
+        expect(gridService.getFilteredRows()).toHaveLength(0);
+        const newRows = [
+            { id: { raw: 10, value: 10 }, name: { raw: 'Zara', value: 'Zara' }, age: { raw: 22, value: 22 } },
+        ];
+        gridService.setRows(newRows);
+        const searchedRows = gridService.getFilteredRows();
+        expect(searchedRows).toHaveLength(1);
+        expect(searchedRows[0].name.value).toBe('Zara');
+    });
+    it('should update global search matches after setColumns', () => {
+        gridService.setGlobalSearch('30', { columns: ['age'] });
+        expect(gridService.getFilteredRows()).toHaveLength(1);
+        gridService.setColumns([
+            { key: 'id', label: 'ID', type: 'integer' },
+            { key: 'name', label: 'Name', type: 'string' },
+        ]);
+        gridService.setGlobalSearch('30');
+        expect(gridService.getFilteredRows()).toHaveLength(0);
+    });
+    it('should emit global search in filterSort$ payload in API mode', (done) => {
+        gridService.enableApiMode({ clientSideSort: false, clientSideFilter: false });
+        gridService.filterSort$.subscribe(({ globalSearch }) => {
+            var _a, _b;
+            if ((globalSearch === null || globalSearch === void 0 ? void 0 : globalSearch.query) === 'alice') {
+                expect((_a = globalSearch.options) === null || _a === void 0 ? void 0 : _a.columns).toEqual(['name']);
+                expect((_b = globalSearch.options) === null || _b === void 0 ? void 0 : _b.caseInsensitive).toBe(true);
+                done();
+            }
+        });
+        gridService.setGlobalSearch('alice', { columns: ['name'], caseInsensitive: true });
+    });
+    it('should support display-mode global search', () => {
+        const durationColumns = [
+            { key: 'name', label: 'Name', type: 'string' },
+            { key: 'sessionDuration', label: 'Session Duration', type: 'duration' },
+        ];
+        const durationRows = [
+            { name: { raw: 'Alice', value: 'Alice' }, sessionDuration: { raw: 3661, value: 3661 } },
+            { name: { raw: 'Bob', value: 'Bob' }, sessionDuration: { raw: 125, value: 125 } },
+        ];
+        const durationGrid = new GridService(durationRows, durationColumns);
+        durationGrid.setGlobalSearch('01:01', { columns: ['sessionDuration'], searchMode: 'display' });
+        const displayMatches = durationGrid.getFilteredRows();
+        expect(displayMatches).toHaveLength(1);
+        expect(displayMatches[0].name.value).toBe('Alice');
+        durationGrid.setGlobalSearch('01:01', { columns: ['sessionDuration'], searchMode: 'raw' });
+        expect(durationGrid.getFilteredRows()).toHaveLength(0);
+    });
+    it('should refresh display-mode global search after display format updates', () => {
+        const dateColumns = [
+            { key: 'name', label: 'Name', type: 'string' },
+            { key: 'created', label: 'Created', type: 'date' },
+        ];
+        const dateRows = [
+            { name: { raw: 'Alice', value: 'Alice' }, created: { raw: '2024-01-15T00:00:00Z', value: new Date('2024-01-15T00:00:00Z').getTime() } },
+            { name: { raw: 'Bob', value: 'Bob' }, created: { raw: '2024-12-31T00:00:00Z', value: new Date('2024-12-31T00:00:00Z').getTime() } },
+        ];
+        const dateGrid = new GridService(dateRows, dateColumns);
+        dateGrid.setGlobalSearch('/', { columns: ['created'], searchMode: 'display' });
+        expect(dateGrid.getFilteredRows()).toHaveLength(0);
+        dateGrid.updateDisplayFormat({ dateFormat: 'dd/MM/yyyy' });
+        expect(dateGrid.getFilteredRows()).toHaveLength(2);
+    });
+    it('should use column globalSearchText callback for component columns', () => {
+        const componentColumns = [
+            { key: 'id', label: 'ID', type: 'integer' },
+            {
+                key: 'status',
+                label: 'Status',
+                type: 'component',
+                globalSearchText: (cell) => {
+                    var _a;
+                    const code = String((_a = cell === null || cell === void 0 ? void 0 : cell.raw) !== null && _a !== void 0 ? _a : '');
+                    if (code === 'A')
+                        return 'Active';
+                    if (code === 'I')
+                        return 'Inactive';
+                    return 'Pending';
+                },
+            },
+        ];
+        const componentRows = [
+            { id: { raw: 1, value: 1 }, status: { raw: 'A', value: 'A' } },
+            { id: { raw: 2, value: 2 }, status: { raw: 'I', value: 'I' } },
+        ];
+        const componentGrid = new GridService(componentRows, componentColumns);
+        componentGrid.setGlobalSearch('inactive', { searchMode: 'display', caseInsensitive: true });
+        const searchedRows = componentGrid.getFilteredRows();
+        expect(searchedRows).toHaveLength(1);
+        expect(searchedRows[0].id.value).toBe(2);
+    });
+    it('should keep sort consistent when global search query changes', () => {
+        var _a, _b, _c;
+        gridService.toggleSort('age');
+        expect((_a = gridService.getSortCondition('age')) === null || _a === void 0 ? void 0 : _a.direction).toBe('asc');
+        gridService.setGlobalSearch('a', { caseInsensitive: true });
+        expect((_b = gridService.getSortCondition('age')) === null || _b === void 0 ? void 0 : _b.direction).toBe('asc');
+        const firstSearch = gridService.getFilteredAndSortRows();
+        expect(firstSearch).toHaveLength(2);
+        expect(firstSearch[0].name.value).toBe('Alice');
+        expect(firstSearch[1].name.value).toBe('Charlie');
+        gridService.setGlobalSearch('bo', { caseInsensitive: true });
+        expect((_c = gridService.getSortCondition('age')) === null || _c === void 0 ? void 0 : _c.direction).toBe('asc');
+        const secondSearch = gridService.getFilteredAndSortRows();
+        expect(secondSearch).toHaveLength(1);
+        expect(secondSearch[0].name.value).toBe('Bob');
+    });
+    it('should combine global search and per-column filter with sorting', () => {
+        gridService.toggleSort('age');
+        gridService.addFilter({ type: 'condition', columnKey: 'age', operator: '>=', value: 30 });
+        gridService.setGlobalSearch('a', { caseInsensitive: true });
+        const rows = gridService.getFilteredAndSortRows();
+        expect(rows).toHaveLength(2);
+        expect(rows[0].name.value).toBe('Alice');
+        expect(rows[1].name.value).toBe('Charlie');
+    });
+    it('should not apply global search locally in API mode when client-side filtering is disabled', () => {
+        gridService.enableApiMode({ clientSideSort: true, clientSideFilter: false });
+        gridService.setRowsFromApi(mockRows);
+        gridService.setGlobalSearch('Alice');
+        gridService.toggleSort('age');
+        const rows = gridService.getFilteredAndSortRows();
+        expect(rows).toHaveLength(3);
+        expect(rows[0].name.value).toBe('Bob');
+        expect(rows[1].name.value).toBe('Alice');
+        expect(rows[2].name.value).toBe('Charlie');
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { GridService } from './GridService';
+export { GridState, Row, RenderRow, Column, ColumnType, DisplayFormat, GridOptions, FilterOption, GlobalSearchMode, GlobalSearchOptions, GlobalSearchState, FilterSortUpdatePayload, } from './types/grid';
+export { SortingCondition } from './types/sorting';
+export { FilterCondition, OperatorType, FilterGroup, FilterNode } from '@open-dcp/filter';

package/dist/index.js

@@ -0,0 +1 @@
+export { GridService } from './GridService';

package/dist/services/FilteringService.d.ts

@@ -0,0 +1,34 @@
+import type { GridService } from "../GridService";
+import type { GlobalSearchOptions, GlobalSearchState, Row } from "../types/grid";
+import { FilterCondition, FilterNode } from "@open-dcp/filter";
+export declare class FilteringService {
+    private readonly gridService;
+    private readonly filteredIndexes$;
+    private filterTree;
+    private globalSearch;
+    private searchableTextCache;
+    private cacheSignature;
+    constructor(gridService: GridService, filterTree?: FilterNode | null);
+    private getColumnKeys;
+    setFilterTree(tree: FilterNode | null): void;
+    getFilterTree(): FilterNode | null;
+    setGlobalSearch(query: string, options?: GlobalSearchOptions): void;
+    clearGlobalSearch(): void;
+    getGlobalSearch(): GlobalSearchState | null;
+    updateFilterIndexesForUpdatedData(): void;
+    private invalidateSearchCache;
+    private getSearchColumns;
+    private toSearchValue;
+    private getCellSearchValue;
+    private getCacheSignature;
+    private ensureSearchCache;
+    private matchesFilterTree;
+    hasFilter(columnKey: string | number): boolean;
+    addFilter(filterNode: FilterNode): void;
+    resetFilters(): void;
+    resetFilter(columnKey: string | number): void;
+    getFilterIndexes(): number[] | null;
+    getFilters(): FilterCondition[];
+    private updateFilterIndexes;
+    applyFilter(rows: Row[]): Row[];
+}

package/dist/services/FilteringService.js

@@ -0,0 +1,278 @@
+import { BehaviorSubject } from "rxjs";
+import { evaluateFilterTree } from "@open-dcp/filter";
+import { logger } from '@open-dcp/utilities';
+export class FilteringService {
+    constructor(gridService, filterTree = null) {
+        this.filteredIndexes$ = new BehaviorSubject(null);
+        this.filterTree = null;
+        this.globalSearch = null;
+        this.searchableTextCache = null;
+        this.cacheSignature = null;
+        this.gridService = gridService;
+        this.filterTree = filterTree;
+    }
+    getColumnKeys(node) {
+        if (node.type === 'condition')
+            return [node.columnKey];
+        if (node.type === 'group') {
+            return node.filters.reduce((acc, filter) => {
+                return acc.concat(this.getColumnKeys(filter));
+            }, []);
+        }
+        return [];
+    }
+    setFilterTree(tree) {
+        this.filterTree = tree;
+        this.updateFilterIndexes();
+    }
+    getFilterTree() {
+        return this.filterTree;
+    }
+    setGlobalSearch(query, options) {
+        const normalizedQuery = query.trim();
+        if (normalizedQuery.length === 0) {
+            this.globalSearch = null;
+            this.updateFilterIndexes();
+            return;
+        }
+        this.globalSearch = {
+            query: normalizedQuery,
+            options: options ? Object.assign({}, options) : undefined,
+        };
+        this.updateFilterIndexes();
+    }
+    clearGlobalSearch() {
+        this.globalSearch = null;
+        this.updateFilterIndexes();
+    }
+    getGlobalSearch() {
+        return this.globalSearch;
+    }
+    updateFilterIndexesForUpdatedData() {
+        this.invalidateSearchCache();
+        this.updateFilterIndexes();
+    }
+    invalidateSearchCache() {
+        this.searchableTextCache = null;
+        this.cacheSignature = null;
+    }
+    getSearchColumns(options) {
+        const allColumns = this.gridService.getColumns();
+        if ((options === null || options === void 0 ? void 0 : options.columns) && options.columns.length > 0) {
+            const keySet = new Set(options.columns);
+            const filteredColumns = allColumns.filter((column) => keySet.has(column.key));
+            if (filteredColumns.length === 0) {
+                logger.warn('DcpGrid: Global search columns do not match any configured columns');
+            }
+            return filteredColumns;
+        }
+        return allColumns;
+    }
+    toSearchValue(value) {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        return String(value);
+    }
+    getCellSearchValue(row, column, searchMode) {
+        const columnKey = column.key;
+        const cell = row[columnKey];
+        const mappedCell = (cell && typeof cell === 'object') ? cell : null;
+        if (typeof column.globalSearchText === 'function') {
+            const customValue = column.globalSearchText(mappedCell, row, searchMode);
+            const customText = this.toSearchValue(customValue);
+            if (customText.length > 0) {
+                return customText;
+            }
+        }
+        if (mappedCell) {
+            if (searchMode === 'raw' && 'raw' in mappedCell) {
+                return this.toSearchValue(mappedCell.raw);
+            }
+            if (searchMode === 'display') {
+                if ('display' in mappedCell) {
+                    const displayText = this.toSearchValue(mappedCell.display);
+                    if (displayText.length > 0) {
+                        return displayText;
+                    }
+                }
+                const formattedDisplay = this.gridService.getCellDisplayValue(row, columnKey);
+                if (formattedDisplay.length > 0) {
+                    return formattedDisplay;
+                }
+                if ('value' in mappedCell) {
+                    return this.toSearchValue(mappedCell.value);
+                }
+                if ('raw' in mappedCell) {
+                    return this.toSearchValue(mappedCell.raw);
+                }
+            }
+            if ('value' in mappedCell) {
+                return this.toSearchValue(mappedCell.value);
+            }
+            if ('raw' in mappedCell) {
+                return this.toSearchValue(mappedCell.raw);
+            }
+        }
+        return this.toSearchValue(cell);
+    }
+    getCacheSignature(columns, caseInsensitive, searchMode) {
+        const columnKeys = columns.map((column) => String(column.key));
+        return `${columnKeys.join('|')}::${caseInsensitive ? 'i' : 's'}::${searchMode}`;
+    }
+    ensureSearchCache(rows, columns, caseInsensitive, searchMode) {
+        const signature = this.getCacheSignature(columns, caseInsensitive, searchMode);
+        if (this.searchableTextCache !== null &&
+            this.cacheSignature === signature &&
+            this.searchableTextCache.length === rows.length) {
+            return;
+        }
+        this.searchableTextCache = rows.map(row => {
+            const baseText = columns
+                .map(column => this.getCellSearchValue(row, column, searchMode))
+                .join(' ');
+            return caseInsensitive ? baseText.toLowerCase() : baseText;
+        });
+        this.cacheSignature = signature;
+    }
+    matchesFilterTree(row) {
+        var _a;
+        if (!this.filterTree) {
+            return true;
+        }
+        return evaluateFilterTree(this.filterTree, row, {
+            caseInsensitive: (_a = this.gridService.gridOptions.caseInsensitiveFiltering) !== null && _a !== void 0 ? _a : false,
+        });
+    }
+    hasFilter(columnKey) {
+        const checkNode = (node) => {
+            if (node.type === 'condition') {
+                return node.columnKey === columnKey;
+            }
+            if (node.type === 'group') {
+                return node.filters.some(checkNode);
+            }
+            return false;
+        };
+        if (!this.filterTree)
+            return false;
+        return checkNode(this.filterTree);
+    }
+    addFilter(filterNode) {
+        const columnKeys = this.getColumnKeys(filterNode);
+        // Start with existing filters (if any)
+        let newFilters = [];
+        if (this.filterTree && this.filterTree.type === 'group') {
+            // Remove all filters for the affected column(s)
+            newFilters = this.filterTree.filters.filter(f => {
+                let keys;
+                if (f.type === 'condition') {
+                    keys = [f.columnKey];
+                }
+                else if (f.type === 'group') {
+                    keys = f.filters.reduce((acc, ff) => {
+                        if (ff.type === 'condition') {
+                            acc.push(ff.columnKey);
+                        }
+                        return acc;
+                    }, []);
+                }
+                else {
+                    keys = [];
+                }
+                return !keys.some(k => columnKeys.includes(k));
+            });
+        }
+        // Add the new filter node
+        newFilters.push(filterNode);
+        // Set the new filter tree
+        this.setFilterTree({
+            type: 'group',
+            operator: 'and',
+            filters: newFilters
+        });
+    }
+    resetFilters() {
+        this.setFilterTree(null);
+    }
+    resetFilter(columnKey) {
+        if (!this.filterTree || this.filterTree.type !== 'group')
+            return;
+        // Remove any filter node (condition or group) that applies to this column
+        const newFilters = this.filterTree.filters.filter(f => !this.getColumnKeys(f).includes(columnKey));
+        // If no filters left, set to null
+        if (newFilters.length === 0) {
+            this.setFilterTree(null);
+        }
+        else {
+            this.setFilterTree(Object.assign(Object.assign({}, this.filterTree), { filters: newFilters }));
+        }
+    }
+    getFilterIndexes() {
+        return this.filteredIndexes$.getValue();
+    }
+    getFilters() {
+        if (!this.filterTree || this.filterTree.type !== 'group')
+            return [];
+        return this.filterTree.filters.filter(f => f.type === 'condition');
+    }
+    updateFilterIndexes() {
+        var _a, _b, _c, _d, _e;
+        const rows = this.gridService.getRows();
+        if (!this.gridService.shouldApplyClientSideFiltering()) {
+            this.filteredIndexes$.next(null);
+            this.gridService.setIndexMapping(new Map([...Array(rows.length).keys()].map(i => [i, i])));
+            this.gridService.updateRenderedRows();
+            return;
+        }
+        if (!this.filterTree && !this.globalSearch) {
+            // No filters: show all rows, identity mapping
+            this.filteredIndexes$.next(null);
+            this.gridService.setIndexMapping(new Map([...Array(this.gridService.rowCount()).keys()].map(i => [i, i])));
+            return;
+        }
+        let globalSearchQuery = null;
+        if (this.globalSearch) {
+            const columns = this.getSearchColumns(this.globalSearch.options);
+            const caseInsensitive = (_c = (_b = (_a = this.globalSearch.options) === null || _a === void 0 ? void 0 : _a.caseInsensitive) !== null && _b !== void 0 ? _b : this.gridService.gridOptions.caseInsensitiveFiltering) !== null && _c !== void 0 ? _c : false;
+            const searchMode = (_e = (_d = this.globalSearch.options) === null || _d === void 0 ? void 0 : _d.searchMode) !== null && _e !== void 0 ? _e : 'value';
+            globalSearchQuery = caseInsensitive ? this.globalSearch.query.toLowerCase() : this.globalSearch.query;
+            this.ensureSearchCache(rows, columns, caseInsensitive, searchMode);
+        }
+        // Find all matching row indexes using both filter tree and global search.
+        const matchingIndexes = rows
+            .map((row, idx) => {
+            var _a, _b;
+            const matchesTree = this.matchesFilterTree(row);
+            if (!matchesTree) {
+                return -1;
+            }
+            if (!globalSearchQuery) {
+                return idx;
+            }
+            const searchableText = (_b = (_a = this.searchableTextCache) === null || _a === void 0 ? void 0 : _a[idx]) !== null && _b !== void 0 ? _b : '';
+            return searchableText.includes(globalSearchQuery) ? idx : -1;
+        })
+            .filter(idx => idx !== -1);
+        // Update index mapping for performance and downstream features
+        this.gridService.clearIndexMap();
+        matchingIndexes.forEach((originalIdx, filteredIdx) => {
+            this.gridService.setIndexMappingValue(filteredIdx, originalIdx);
+        });
+        this.filteredIndexes$.next(matchingIndexes);
+    }
+    applyFilter(rows) {
+        const filteredIndexes = this.filteredIndexes$.getValue();
+        if (filteredIndexes === null) {
+            return rows;
+        }
+        this.gridService.clearIndexMap();
+        filteredIndexes.forEach((filteredIndex, i) => {
+            this.gridService.setIndexMappingValue(i, filteredIndex);
+        });
+        return filteredIndexes.map(index => rows[index]);
+    }
+}

package/dist/services/FormattingService.d.ts

@@ -0,0 +1,17 @@
+import type { GridService } from "../GridService";
+import { Column, DisplayValue, Row } from "../types/grid";
+export declare class FormattingService {
+    private readonly gridService;
+    constructor(gridService: GridService);
+    applyFormattingToRow(row: Row): Row;
+    private formatCustomCell;
+    private formatDateCell;
+    formatCellDisplay(row: Row, column: Column): DisplayValue;
+    private transformCustomOrComponent;
+    private transformInteger;
+    private transformNumber;
+    private transformDate;
+    private transformDuration;
+    private transformString;
+    formatCellValue(row: Row, column: Column): any;
+}