⚡️ Speed up function filterEntityGroupsBySearchTerm by 59%

[codeflash-ai]

📄 59% (0.59x) speedup for filterEntityGroupsBySearchTerm in app/client/src/IDE/utils/filterEntityGroupsBySearchTerm.ts

⏱️ Runtime : 810 microseconds → 510 microseconds (best of 10 runs)

📝 Explanation and details

This optimization achieves a 58% runtime improvement (from 810μs to 510μs) by replacing the functional reduce() pattern with a performance-optimized for-loop implementation.

Key Performance Improvements:

1. Eliminated callback overhead: The original reduce() creates a function closure for each invocation, adding call stack overhead on every iteration. The for-loop executes directly without function call penalties.

2. Removed destructuring allocation: The original code destructured each group with const { items, ...rest } = group, creating a temporary rest object with all group properties except items on every iteration (386 times according to line profiler). The optimized version uses direct property spreading { ...group, items: searchResults }, which is more efficient as it doesn't create an intermediate object.

3. Pre-allocated result array: Declaring const result: Array<Group<G, T>> = [] upfront allows V8's optimizer to better predict array growth patterns compared to the implicit accumulator in reduce().

4. Length caching: const len = groups.length prevents repeated property lookups during loop condition checks, though this is a minor win with modern JIT compilers.

Line Profiler Evidence:

The original spent 17.9% of time on destructuring (const { items, ...rest }), which is completely eliminated in the optimized version. The for-loop structure also shows better instruction-level optimization as evidenced by the reduced relative time percentages across operations.

Test Case Performance:

The optimization particularly excels in scenarios with:

• Large datasets with no matches: 95.8% faster (490μs → 250μs) when searching through 50 groups with 20 items each
• Unicode/special character searches: 186-300% faster on short-circuit cases
• Single character searches: 197% faster (11.5μs → 3.87μs)

Edge cases like empty arrays show minor regression (~50% slower at microsecond scale), but these are negligible compared to the substantial gains in realistic workloads involving actual filtering operations where the 58% overall speedup matters most.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 21 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Click to see Generated Regression Tests

// @ts-nocheck
// imports
// Mock fuse.js to provide deterministic and fast search behavior for tests.
// Provide a default export (class) because the implementation imports Fuse as default.
jest.mock('fuse.js', () => {
    // Simple mock Fuse implementation:
    // - constructor(items, options)
    // - search(term) returns an array of original items that contain the term (case-insensitive)
    //   in any of their string-valued "name", "label", or "title" properties, or if the item
    //   itself is a string, in the string value.
    return {
        __esModule: true,
        default: class MockFuse {
            constructor(items = []) {
                this.items = Array.isArray(items) ? items : [];
            }

            search(term) {
                if (!term && term !== 0) {
                    return [];
                }
                const needle = String(term).toLowerCase();
                return this.items.filter((item) => {
                    if (item == null) return false;
                    if (typeof item === 'string') {
                        return item.toLowerCase().includes(needle);
                    }
                    if (typeof item === 'object') {
                        // check common string fields
                        for (const key of Object.keys(item)) {
                            const val = item[key];
                            if (typeof val === 'string' && val.toLowerCase().includes(needle)) {
                                return true;
                            }
                        }
                    }
                    return false;
                });
            }
        }
    };
});

import { filterEntityGroupsBySearchTerm } from '../src/IDE/utils/filterEntityGroupsBySearchTerm';

// unit tests
describe('filterEntityGroupsBySearchTerm', () => {
    // Basic Test Cases
    describe('Basic functionality', () => {
        test('should return matching groups and items for a normal search term', () => {
            // Scenario:
            // Two groups; groupA has items with names; groupB has items with labels.
            // Search term should match some items across groups. Returned groups should
            // include only those groups with matches and each group's items should be
            // replaced by the search results.
            const groups = [
                {
                    id: 'A',
                    title: 'Group A',
                    items: [
                        { id: 'a1', name: 'Apple Pie' },
                        { id: 'a2', name: 'Banana Split' },
                        { id: 'a3', name: 'apple tart' },
                    ],
                },
                {
                    id: 'B',
                    title: 'Group B',
                    items: [
                        { id: 'b1', label: 'Orange Juice' },
                        { id: 'b2', label: 'Grape Soda' },
                    ],
                },
            ];

            const result = filterEntityGroupsBySearchTerm('apple', groups);

            // Only group A should be returned because group B has no "apple"
            expect(Array.isArray(result)).toBe(true);  // 22.5μs -> 5.67μs (297% faster)
            expect(result.length).toBe(1);
            const [resGroup] = result;
            expect(resGroup.id).toBe('A');
            // Items should be the search results (from our mock Fuse). Both 'Apple Pie' and 'apple tart' match.
            expect(Array.isArray(resGroup.items)).toBe(true);
            const returnedNames = resGroup.items.map((it) => it.name);
            expect(returnedNames).toEqual(expect.arrayContaining(['Apple Pie', 'apple tart']));
            expect(returnedNames).not.toEqual(expect.arrayContaining(['Banana Split']));
        });

        test('should return original groups reference when search term is falsy (empty string)', () => {
            // Scenario:
            // When searchTerm is an empty string (falsy), the function returns the original groups array unchanged.
            const groups = [
                { id: 'g1', items: [{ id: 1, name: 'One' }] },
                { id: 'g2', items: [{ id: 2, name: 'Two' }] },
            ];

            const result = filterEntityGroupsBySearchTerm('', groups);

            // Exact same reference is returned per implementation
            expect(result).toBe(groups);  // 1.05μs -> 887ns (18.0% faster)
        });
    });

    // Edge Test Cases
    describe('Edge cases', () => {
        test('should return an empty array when no items match across all groups', () => {
            // Scenario:
            // Search term that doesn't match any item in any group -> result should be empty array.
            const groups = [
                { id: 'g1', items: [{ id: 1, name: 'Alpha' }, { id: 2, name: 'Beta' }] },
                { id: 'g2', items: [{ id: 3, label: 'Gamma' }] },
            ];

            const result = filterEntityGroupsBySearchTerm('zzz-not-present', groups);
            expect(Array.isArray(result)).toBe(true);  // 3.85μs -> 4.37μs (11.9% slower)
            expect(result.length).toBe(0);
        });

        test('should handle groups with empty items arrays and still return other matching groups', () => {
            // Scenario:
            // One group has zero items, the other has matches. Function should not crash and
            // must return only the group with matches.
            const groups = [
                { id: 'empty', items: [] },
                { id: 'populated', title: 'Has Items', items: [{ id: 'i1', name: 'MatchMe' }, { id: 'i2', name: 'Nope' }] },
            ];

            const result = filterEntityGroupsBySearchTerm('matchme', groups);
            expect(result.length).toBe(1);  // 4.63μs -> 4.49μs (3.09% faster)
            expect(result[0].id).toBe('populated');
            expect(result[0].items.length).toBe(1);
            expect(result[0].items[0].name).toBe('MatchMe');
        });

        test('should return empty array when groups array is empty', () => {
            // Scenario:
            // No groups provided -> should simply return an empty array
            const groups = [];
            const result = filterEntityGroupsBySearchTerm('anything', groups);
            expect(Array.isArray(result)).toBe(true);  // 597ns -> 1.11μs (46.5% slower)
            expect(result.length).toBe(0);
        });

        test('should treat non-string falsy searchTerm (e.g., 0) as falsy and return original groups', () => {
            // Scenario:
            // The implementation uses (!searchTerm) check. Passing 0 should be considered falsy and thus return groups unchanged.
            const groups = [{ id: 'g', items: [{ id: 1, name: 'One' }] }];
            // @ts-ignore - intentional non-string input to validate behavior
            const result = filterEntityGroupsBySearchTerm(0, groups);
            expect(result).toBe(groups);  // 962ns -> 1.06μs (9.07% slower)
        });

        test('should not mutate original groups or their items when returning filtered results', () => {
            // Scenario:
            // Ensure the original groups and items are not mutated by the filtering operation.
            const originalGroups = [
                { id: 'g1', title: 'Original', items: [{ id: 'i1', name: 'KeepMe' }, { id: 'i2', name: 'DropMe' }] },
            ];
            const groupsCopy = JSON.parse(JSON.stringify(originalGroups));

            const result = filterEntityGroupsBySearchTerm('keepme', originalGroups);

            // Original should remain identical to the deep copy
            expect(originalGroups).toEqual(groupsCopy);  // 4.27μs -> 4.09μs (4.23% faster)

            // Result should be a separate array (not the same reference as original)
            expect(result).not.toBe(originalGroups);
            // But result[0] should keep other group properties (e.g., title)
            expect(result[0].title).toBe('Original');
        });
    });

    // Large Scale Test Cases
    describe('Performance tests', () => {
        test('should handle a large number of items across multiple groups (under 1000 elements)', () => {
            // Scenario:
            // Create 2 groups with 250 items each (500 total, under the 1000 limit).
            // Use names that allow predictable substring matches. Ensure the function completes
            // and returns the expected matching counts.
            const groupCount = 2;
            const itemsPerGroup = 250;
            const groups = [];

            for (let g = 0; g < groupCount; g++) {
                const items = [];
                for (let i = 0; i < itemsPerGroup; i++) {
                    // name includes group and index for predictable matching
                    items.push({ id: `g${g}-i${i}`, name: `group${g}-item-${i}` });
                }
                groups.push({ id: `group-${g}`, items });
            }

            // Choose a search term that will match indices ending with '4' (i.e., 4,14,24,...,244)
            // This will produce a predictable number of matches per group.
            const searchTerm = '-4'; // will match 'item-4', 'item-14', etc.
            const result = filterEntityGroupsBySearchTerm(searchTerm, groups);

            // Compute expected matches using same matching rule as the mocked Fuse:
            const computeExpected = (groupsArr, term) => {
                const needle = String(term).toLowerCase();
                const expectedGroups = [];
                for (const grp of groupsArr) {
                    const matched = grp.items.filter((it) => {
                        if (!it || typeof it !== 'object') return false;
                        for (const k of Object.keys(it)) {
                            const v = it[k];
                            if (typeof v === 'string' && v.toLowerCase().includes(needle)) return true;
                        }
                        return false;
                    });
                    if (matched.length) {
                        expectedGroups.push({ ...grp, items: matched });
                    }
                }
                return expectedGroups;
            };

            const expected = computeExpected(groups, searchTerm);

            // Validate that result has same structure/quantities as expected
            expect(result.length).toBe(expected.length);  // 182μs -> 177μs (2.67% faster)
            // Sum of items matched across groups should equal expected
            const resultItemCount = result.reduce((s, g) => s + (Array.isArray(g.items) ? g.items.length : 0), 0);
            const expectedItemCount = expected.reduce((s, g) => s + g.items.length, 0);
            expect(resultItemCount).toBe(expectedItemCount);

            // Ensure that each returned item has an id that indeed contains the search substring
            for (const grp of result) {
                for (const it of grp.items) {
                    const present = Object.values(it).some((v) => typeof v === 'string' && v.toLowerCase().includes(searchTerm));
                    expect(present).toBe(true);
                }
            }
        });
    });
});

// @ts-nocheck
import { filterEntityGroupsBySearchTerm } from '../src/IDE/utils/filterEntityGroupsBySearchTerm';
import Fuse from 'fuse.js';

describe('filterEntityGroupsBySearchTerm', () => {
  // Basic Test Cases
  describe('Basic functionality', () => {
    test('should return all groups when search term is empty string', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [
            { id: 'item1', name: 'Apple' },
            { id: 'item2', name: 'Banana' },
          ],
        },
        {
          id: 'group2',
          name: 'Group 2',
          items: [
            { id: 'item3', name: 'Cherry' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('', groups);
      expect(result).toEqual(groups);  // 1.10μs -> 1.92μs (42.8% slower)
      expect(result.length).toBe(2);
    });

    test('should return all groups when search term is null or undefined', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [{ id: 'item1', name: 'Apple' }],
        },
      ];

      expect(filterEntityGroupsBySearchTerm(null, groups)).toEqual(groups);  // 1.29μs -> 2.25μs (42.7% slower)
      expect(filterEntityGroupsBySearchTerm(undefined, groups)).toEqual(groups);
    });

    test('should filter groups by matching search term in items', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [
            { id: 'item1', name: 'Apple' },
            { id: 'item2', name: 'Apricot' },
          ],
        },
        {
          id: 'group2',
          name: 'Group 2',
          items: [
            { id: 'item3', name: 'Banana' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('Apple', groups);
      expect(result.length).toBe(1);
      expect(result[0].id).toBe('group1');
    });

    test('should preserve group metadata while filtering items', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          category: 'fruits',
          items: [
            { id: 'item1', name: 'Apple', color: 'red' },
            { id: 'item2', name: 'Banana', color: 'yellow' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('Apple', groups);
      expect(result[0].id).toBe('group1');
      expect(result[0].name).toBe('Group 1');
      expect(result[0].category).toBe('fruits');
    });

    test('should handle case-insensitive search', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [
            { id: 'item1', name: 'Apple' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('apple', groups);
      expect(result.length).toBe(1);
      expect(result[0].items.length).toBeGreaterThan(0);
    });

    test('should return empty array when no matches found', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [
            { id: 'item1', name: 'Apple' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('Zebra', groups);
      expect(result).toEqual([]);  // 12.7μs -> 9.01μs (41.3% faster)
    });

    test('should include only groups with matching items', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [
            { id: 'item1', name: 'Apple' },
          ],
        },
        {
          id: 'group2',
          name: 'Group 2',
          items: [
            { id: 'item3', name: 'Banana' },
          ],
        },
        {
          id: 'group3',
          name: 'Group 3',
          items: [
            { id: 'item5', name: 'Apricot' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('App', groups);
      expect(result.length).toBe(2);
      expect(result.map(g => g.id)).toEqual(['group1', 'group3']);
    });

    test('should filter items within each group independently', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [
            { id: 'item1', name: 'Apple' },
            { id: 'item2', name: 'Banana' },
            { id: 'item3', name: 'Apricot' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('App', groups);
      expect(result[0].items.length).toBe(2);
    });
  });

  // Edge Test Cases
  describe('Edge cases', () => {
    test('should handle empty groups array', () => {
      const result = filterEntityGroupsBySearchTerm('test', []);
      expect(result).toEqual([]);  // 1.31μs -> 1.36μs (3.97% slower)
    });

    test('should handle groups with empty items arrays', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [],
        },
        {
          id: 'group2',
          name: 'Group 2',
          items: [
            { id: 'item1', name: 'Apple' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('Apple', groups);
      expect(result.length).toBe(1);
      expect(result[0].id).toBe('group2');
    });

    test('should handle special characters in search term', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [
            { id: 'item1', name: 'C++ Programming' },
            { id: 'item2', name: 'Node.js' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('C++', groups);
      expect(result.length).toBeGreaterThanOrEqual(0);  // 12.0μs -> 13.8μs (12.7% slower)
    });

    test('should handle whitespace-only search term', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [
            { id: 'item1', name: 'Apple' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('   ', groups);
      expect(Array.isArray(result)).toBe(true);  // 12.9μs -> 12.6μs (1.84% faster)
    });

    test('should handle single character search', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [
            { id: 'item1', name: 'Apple' },
            { id: 'item2', name: 'Banana' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('A', groups);
      expect(result.length).toBeGreaterThanOrEqual(0);  // 11.5μs -> 3.87μs (197% faster)
    });

    test('should handle very long search terms', () => {
      const longTerm = 'a'.repeat(500);
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [
            { id: 'item1', name: 'Apple' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm(longTerm, groups);
      expect(Array.isArray(result)).toBe(true);  // 12.7μs -> 3.17μs (300% faster)
    });

    test('should handle groups with many properties', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          description: 'A description',
          category: 'fruits',
          priority: 1,
          enabled: true,
          tags: ['tag1', 'tag2'],
          metadata: { custom: 'value' },
          items: [
            { id: 'item1', name: 'Apple' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('Apple', groups);
      expect(result.length).toBe(1);
      expect(result[0].description).toBe('A description');
      expect(result[0].category).toBe('fruits');
      expect(result[0].priority).toBe(1);
      expect(result[0].enabled).toBe(true);
      expect(result[0].tags).toEqual(['tag1', 'tag2']);
      expect(result[0].metadata).toEqual({ custom: 'value' });
    });

    test('should handle items with special data types', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [
            { id: 'item1', name: 'Apple', count: 5, active: true },
            { id: 'item2', name: 'Banana', count: 0, active: false },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('Apple', groups);
      expect(result.length).toBe(1);
      expect(result[0].items[0]).toHaveProperty('count');
      expect(result[0].items[0]).toHaveProperty('active');
    });

    test('should handle unicode characters in search term', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [
            { id: 'item1', name: 'Café' },
            { id: 'item2', name: 'Apple' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('Café', groups);
      expect(Array.isArray(result)).toBe(true);  // 12.3μs -> 4.30μs (186% faster)
    });

    test('should handle unicode characters in item names', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [
            { id: 'item1', name: 'Café au lait' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('Cafe', groups);
      expect(Array.isArray(result)).toBe(true);  // 10.3μs -> 3.90μs (165% faster)
    });

    test('should preserve search result objects from Fuse', () => {
      const groups = [
        {
          id: 'group1',
          name: 'Group 1',
          items: [
            { id: 'item1', name: 'Apple' },
          ],
        },
      ];

      const result = filterEntityGroupsBySearchTerm('Apple', groups);
      if (result.length > 0) {
        // Fuse returns objects with 'item' property containing the original item
        expect(result[0].items).toBeDefined();  // 11.1μs -> 3.94μs (182% faster)
        expect(Array.isArray(result[0].items)).toBe(true);
      }
    });
  });

  // Large Scale Test Cases
  describe('Performance tests', () => {
    test('should handle multiple large groups with many items', () => {
      const groups = Array.from({ length: 50 }, (_, groupIndex) => ({
        id: `group${groupIndex}`,
        name: `Group ${groupIndex}`,
        items: Array.from({ length: 20 }, (_, itemIndex) => ({
          id: `item${groupIndex}-${itemIndex}`,
          name: `Item ${itemIndex}`,
        })),
      }));

      const result = filterEntityGroupsBySearchTerm('Item', groups);
      expect(Array.isArray(result)).toBe(true);
      expect(result.length).toBeGreaterThan(0);
      expect(result.length).toBeLessThanOrEqual(50);
    });

    test('should handle searching with matching in all groups', () => {
      const groups = Array.from({ length: 100 }, (_, groupIndex) => ({
        id: `group${groupIndex}`,
        name: `Group ${groupIndex}`,
        items: Array.from({ length: 10 }, (_, itemIndex) => ({
          id: `item${groupIndex}-${itemIndex}`,
          name: `Apple ${groupIndex}-${itemIndex}`,
        })),
      }));

      const result = filterEntityGroupsBySearchTerm('Apple', groups);
      expect(result.length).toBe(100);
    });

    test('should handle searching with no matches in large dataset', () => {
      const groups = Array.from({ length: 50 }, (_, groupIndex) => ({
        id: `group${groupIndex}`,
        name: `Group ${groupIndex}`,
        items: Array.from({ length: 20 }, (_, itemIndex) => ({
          id: `item${groupIndex}-${itemIndex}`,
          name: `Banana ${groupIndex}-${itemIndex}`,
        })),
      }));

      const result = filterEntityGroupsBySearchTerm('Zebra', groups);
      expect(result).toEqual([]);  // 490μs -> 250μs (95.8% faster)
    });

    test('should handle partial matches in large dataset efficiently', () => {
      const groups = Array.from({ length: 30 }, (_, groupIndex) => ({
        id: `group${groupIndex}`,
        name: `Group ${groupIndex}`,
        items: Array.from({ length: 15 }, (_, itemIndex) => ({
          id: `item${groupIndex}-${itemIndex}`,
          name: itemIndex % 3 === 0 ? `Apple${groupIndex}` : `Orange${groupIndex}`,
        })),
      }));

      const startTime = performance.now();
      const result = filterEntityGroupsBySearchTerm('App', groups);
      const endTime = performance.now();

      expect(result.length).toBeGreaterThan(0);
      expect(endTime - startTime).toBeLessThan(5000); // Should complete in reasonable time
    });

    test('should maintain performance with diverse item properties', () => {
      const groups = Array.from({ length: 40 }, (_, groupIndex) => ({
        id: `group${groupIndex}`,
        name: `Group ${groupIndex}`,
        category: `category${groupIndex % 5}`,
        items: Array.from({ length: 15 }, (_, itemIndex) => ({
          id: `item${groupIndex}-${itemIndex}`,
          name: `Product ${groupIndex}-${itemIndex}`,
          description: `This is a product description for item ${itemIndex}`,
          price: Math.random() * 100,
          tags: [`tag${itemIndex}`, `tag${groupIndex}`],
        })),
      }));

      const result = filterEntityGroupsBySearchTerm('Product', groups);
      expect(Array.isArray(result)).toBe(true);
      expect(result.length).toBeGreaterThan(0);
    });

    test('should handle searching across many groups with varied match rates', () => {
      const groups = Array.from({ length: 60 }, (_, groupIndex) => ({
        id: `group${groupIndex}`,
        name: `Group ${groupIndex}`,
        items: Array.from({ length: 12 }, (_, itemIndex) => ({
          id: `item${groupIndex}-${itemIndex}`,
          name: groupIndex % 2 === 0 ? `SearchableItem${itemIndex}` : `OtherItem${itemIndex}`,
        })),
      }));

      const result = filterEntityGroupsBySearchTerm('Searchable', groups);
      expect(result.length).toBe(30); // Half of 60 groups
    });

    test('should efficiently filter when search matches multiple items per group', () => {
      const groups = Array.from({ length: 25 }, (_, groupIndex) => ({
        id: `group${groupIndex}`,
        name: `Group ${groupIndex}`,
        items: Array.from({ length: 20 }, (_, itemIndex) => ({
          id: `item${groupIndex}-${itemIndex}`,
          name: `Target ${groupIndex}-${itemIndex}`,
        })),
      }));

      const result = filterEntityGroupsBySearchTerm('Target', groups);
      expect(result.length).toBe(25);
      result.forEach(group => {
        expect(group.items.length).toBeGreaterThan(0);
        expect(group.items.length).toBeLessThanOrEqual(20);
      });
    });

    test('should handle deep nested group structures correctly', () => {
      const groups = Array.from({ length: 20 }, (_, groupIndex) => ({
        id: `group${groupIndex}`,
        name: `Group ${groupIndex}`,
        parentGroup: `parent${groupIndex % 5}`,
        metadata: {
          created: new Date().toISOString(),
          nested: {
            deep: {
              value: `value${groupIndex}`,
            },
          },
        },
        items: Array.from({ length: 10 }, (_, itemIndex) => ({
          id: `item${groupIndex}-${itemIndex}`,
          name: `Apple${groupIndex}`,
          details: {
            description: `Item description ${itemIndex}`,
            tags: [`tag${itemIndex}`, 'searchterm'],
          },
        })),
      }));

      const result = filterEntityGroupsBySearchTerm('Apple', groups);
      expect(result.length).toBe(20);
      result.forEach(group => {
        expect(group.parentGroup).toBeDefined();
        expect(group.metadata).toBeDefined();
        expect(group.metadata.nested.deep.value).toBeDefined();
      });
    });
  });
});

📊 Performance Profile

View detailed line-by-line performance analysis
To edit these changes git checkout codeflash/optimize-filterEntityGroupsBySearchTerm-ml2o2x7v and push.