@cccsaurora/howler-ui 2.18.0-dev.736 → 2.18.0-dev.739

package/components/app/providers/ParameterProvider.test.js

@@ -1,18 +1,23 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { act, renderHook, waitFor } from '@testing-library/react';
-import { setupReactRouterMock } from '@cccsaurora/howler-ui/tests/mocks';
 import { useContextSelector } from 'use-context-selector';
 import { DEFAULT_QUERY } from '@cccsaurora/howler-ui/utils/constants';
 import ParameterProvider, { ParameterContext } from './ParameterProvider';
 // Mock dependencies
-const { mockParams, mockLocation, mockSetParams, mockSearchParams } = setupReactRouterMock();
+const mockSetParams = vi.fn();
+const mockLocation = { pathname: '/hits', search: '' };
+const mockParams = { id: undefined };
+let mockSearchParams = new URLSearchParams();
+vi.mock('react-router-dom', () => ({
+    useLocation: vi.fn(() => mockLocation),
+    useParams: vi.fn(() => mockParams),
+    useSearchParams: vi.fn(() => [mockSearchParams, mockSetParams])
+}));
 const Wrapper = ({ children }) => {
     return _jsx(ParameterProvider, { children: children });
 };
 beforeEach(() => {
-    for (const key of [...mockSearchParams.keys()]) {
-        mockSearchParams.delete(key);
-    }
+    mockSearchParams = new URLSearchParams();
     mockSetParams.mockClear();
     mockLocation.pathname = '/hits';
     mockLocation.search = '';
@@ -34,13 +39,15 @@ describe('ParameterContext', () => {
         expect(hook.result.current.trackTotalHits).toBe(false);
     });
     it('should initialize with values from URL params', async () => {
-        mockSearchParams.set('query', 'test query');
-        mockSearchParams.set('sort', 'test.field asc');
-        mockSearchParams.set('span', 'date.range.1.week');
-        mockSearchParams.set('offset', '25');
-        mockSearchParams.set('selected', 'test_id');
-        mockSearchParams.set('filter', 'status:open');
-        mockSearchParams.set('track_total_hits', 'true');
+        mockSearchParams = new URLSearchParams({
+            query: 'test query',
+            sort: 'test.field asc',
+            span: 'date.range.1.week',
+            offset: '25',
+            selected: 'test_id',
+            filter: 'status:open',
+            track_total_hits: 'true'
+        });
         const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
             query: ctx.query,
             sort: ctx.sort,
@@ -59,9 +66,11 @@ describe('ParameterContext', () => {
         expect(hook.result.current.trackTotalHits).toBe(true);
     });
     it('should handle custom date span with start and end dates', async () => {
-        mockSearchParams.set('span', 'date.range.custom');
-        mockSearchParams.set('start_date', '2025-01-01');
-        mockSearchParams.set('end_date', '2025-12-31');
+        mockSearchParams = new URLSearchParams({
+            span: 'date.range.custom',
+            start_date: '2025-01-01',
+            end_date: '2025-12-31'
+        });
         const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
             span: ctx.span,
             startDate: ctx.startDate,
@@ -85,7 +94,7 @@ describe('ParameterContext', () => {
             });
         });
         it('should not update if the value is the same', async () => {
-            mockSearchParams.set('query', 'existing query');
+            mockSearchParams = new URLSearchParams({ query: 'existing query' });
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                 query: ctx.query,
                 setQuery: ctx.setQuery
@@ -125,9 +134,11 @@ describe('ParameterContext', () => {
             });
         });
         it('should clear startDate and endDate when span does not end with custom', async () => {
-            mockSearchParams.set('span', 'date.range.custom');
-            mockSearchParams.set('start_date', '2025-01-01');
-            mockSearchParams.set('end_date', '2025-12-31');
+            mockSearchParams = new URLSearchParams({
+                span: 'date.range.custom',
+                start_date: '2025-01-01',
+                end_date: '2025-12-31'
+            });
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                 span: ctx.span,
                 startDate: ctx.startDate,
@@ -150,17 +161,19 @@ describe('ParameterContext', () => {
             expect(hook.result.current).toEqual([]);
         });
         it('should initialize with single filter from URL', async () => {
-            mockSearchParams.set('filter', 'status:open');
+            mockSearchParams = new URLSearchParams({ filter: 'status:open' });
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.filters), { wrapper: Wrapper });
             expect(hook.result.current).toEqual(['status:open']);
         });
         it('should initialize with multiple filters from URL', async () => {
+            mockSearchParams = new URLSearchParams();
             mockSearchParams.append('filter', 'howler.escalation:hit');
             mockSearchParams.append('filter', 'howler.assignment:someuser');
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.filters), { wrapper: Wrapper });
             expect(hook.result.current).toEqual(['howler.escalation:hit', 'howler.assignment:someuser']);
         });
         it('should preserve filter order from URL', async () => {
+            mockSearchParams = new URLSearchParams();
             mockSearchParams.append('filter', 'c');
             mockSearchParams.append('filter', 'a');
             mockSearchParams.append('filter', 'b');
@@ -168,6 +181,7 @@ describe('ParameterContext', () => {
             expect(hook.result.current).toEqual(['c', 'a', 'b']);
         });
         it('should deduplicate multiple empty filter params to single empty string', async () => {
+            mockSearchParams = new URLSearchParams();
             mockSearchParams.append('filter', '');
             mockSearchParams.append('filter', '');
             mockSearchParams.append('filter', '');
@@ -188,7 +202,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should append filter to existing filters', async () => {
-                mockSearchParams.set('filter', 'existing:filter');
+                mockSearchParams = new URLSearchParams({ filter: 'existing:filter' });
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     filters: ctx.filters,
                     addFilter: ctx.addFilter
@@ -201,7 +215,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should not add duplicate filters', async () => {
-                mockSearchParams.set('filter', 'status:open');
+                mockSearchParams = new URLSearchParams({ filter: 'status:open' });
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     filters: ctx.filters,
                     addFilter: ctx.addFilter
@@ -217,6 +231,7 @@ describe('ParameterContext', () => {
         });
         describe('removeFilter', () => {
             it('should remove first matching filter', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('filter', 'filter1');
                 mockSearchParams.append('filter', 'filter2');
                 mockSearchParams.append('filter', 'filter3');
@@ -232,7 +247,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should do nothing when removing nonexistent filter', async () => {
-                mockSearchParams.set('filter', 'existing');
+                mockSearchParams = new URLSearchParams({ filter: 'existing' });
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     filters: ctx.filters,
                     removeFilter: ctx.removeFilter
@@ -257,16 +272,17 @@ describe('ParameterContext', () => {
                 });
             });
         });
-        describe('resetFilters', () => {
+        describe('clearFilters', () => {
             it('should clear all filters', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('filter', 'filter1');
                 mockSearchParams.append('filter', 'filter2');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     filters: ctx.filters,
-                    resetFilters: ctx.resetFilters
+                    clearFilters: ctx.clearFilters
                 })), { wrapper: Wrapper });
                 await act(async () => {
-                    hook.result.current.resetFilters();
+                    hook.result.current.clearFilters();
                 });
                 await waitFor(() => {
                     expect(hook.result.current.filters).toEqual([]);
@@ -275,10 +291,10 @@ describe('ParameterContext', () => {
             it('should be no-op when already empty', async () => {
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     filters: ctx.filters,
-                    resetFilters: ctx.resetFilters
+                    clearFilters: ctx.clearFilters
                 })), { wrapper: Wrapper });
                 await act(async () => {
-                    hook.result.current.resetFilters();
+                    hook.result.current.clearFilters();
                 });
                 await waitFor(() => {
                     expect(hook.result.current.filters).toEqual([]);
@@ -287,6 +303,7 @@ describe('ParameterContext', () => {
         });
         describe('setFilter', () => {
             it('should update filter at specified index', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('filter', 'filter1');
                 mockSearchParams.append('filter', 'filter2');
                 mockSearchParams.append('filter', 'filter3');
@@ -302,6 +319,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should update filter at index 0', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('filter', 'old:filter');
                 mockSearchParams.append('filter', 'filter2');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
@@ -316,6 +334,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should update filter at last index', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('filter', 'filter1');
                 mockSearchParams.append('filter', 'old:last');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
@@ -330,7 +349,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should do nothing when index is out of bounds', async () => {
-                mockSearchParams.set('filter', 'existing');
+                mockSearchParams = new URLSearchParams({ filter: 'existing' });
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     filters: ctx.filters,
                     setFilter: ctx.setFilter
@@ -343,7 +362,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should do nothing when index is negative', async () => {
-                mockSearchParams.set('filter', 'existing');
+                mockSearchParams = new URLSearchParams({ filter: 'existing' });
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     filters: ctx.filters,
                     setFilter: ctx.setFilter
@@ -368,6 +387,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should sync updated filter to URL', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('filter', 'filter1');
                 mockSearchParams.append('filter', 'filter2');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
@@ -417,13 +437,14 @@ describe('ParameterContext', () => {
                 });
             });
             it('should remove all filter params when filters is empty', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('filter', 'filter1');
                 mockSearchParams.append('filter', 'filter2');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    resetFilters: ctx.resetFilters
+                    clearFilters: ctx.clearFilters
                 })), { wrapper: Wrapper });
                 await act(async () => {
-                    hook.result.current.resetFilters();
+                    hook.result.current.clearFilters();
                 });
                 await waitFor(() => {
                     expect(mockSetParams).toHaveBeenCalled();
@@ -546,11 +567,11 @@ describe('ParameterContext', () => {
             });
         });
         it('should read changes from URL params', async () => {
-            mockSearchParams.set('query', 'initial query');
+            mockSearchParams = new URLSearchParams({ query: 'initial query' });
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.query), { wrapper: Wrapper });
             expect(hook.result.current).toBe('initial query');
             // Simulate URL change
-            mockSearchParams.set('query', 'updated query');
+            mockSearchParams = new URLSearchParams({ query: 'updated query' });
             mockLocation.search = '?query=updated%20query';
             hook.rerender();
             await waitFor(() => {
@@ -568,22 +589,24 @@ describe('ParameterContext', () => {
         it('should handle selected parameter in bundle when it matches bundle id', async () => {
             mockLocation.pathname = '/bundles/bundle_123';
             mockParams.id = 'bundle_123';
-            mockSearchParams.set('selected', 'bundle_123');
+            mockSearchParams = new URLSearchParams({ selected: 'bundle_123' });
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.selected), { wrapper: Wrapper });
             expect(hook.result.current).toBe('bundle_123');
         });
         it('should handle selected parameter in bundle when it differs from bundle id', async () => {
             mockLocation.pathname = '/bundles/bundle_123';
             mockParams.id = 'bundle_123';
-            mockSearchParams.set('selected', 'different_hit_id');
+            mockSearchParams = new URLSearchParams({ selected: 'different_hit_id' });
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.selected), { wrapper: Wrapper });
             expect(hook.result.current).toBe('different_hit_id');
         });
     });
     describe('useParameterContextSelector', () => {
         it('should allow selecting specific values from context', async () => {
-            mockSearchParams.set('query', 'test query');
-            mockSearchParams.set('sort', 'test.field asc');
+            mockSearchParams = new URLSearchParams({
+                query: 'test query',
+                sort: 'test.field asc'
+            });
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                 query: ctx.query,
                 sort: ctx.sort
@@ -594,17 +617,17 @@ describe('ParameterContext', () => {
     });
     describe('edge cases', () => {
         it('should handle offset of 0 in URL params', async () => {
-            mockSearchParams.set('offset', '0');
+            mockSearchParams = new URLSearchParams({ offset: '0' });
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.offset), { wrapper: Wrapper });
             expect(hook.result.current).toBe(0);
         });
         it('should handle trackTotalHits with various values', async () => {
-            mockSearchParams.set('track_total_hits', 'false');
+            mockSearchParams = new URLSearchParams({ track_total_hits: 'false' });
             let hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.trackTotalHits), {
                 wrapper: Wrapper
             });
             expect(hook.result.current).toBe(false);
-            mockSearchParams.set('track_total_hits', 'true');
+            mockSearchParams = new URLSearchParams({ track_total_hits: 'true' });
             hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.trackTotalHits), { wrapper: Wrapper });
             expect(hook.result.current).toBe(true);
         });
@@ -622,9 +645,11 @@ describe('ParameterContext', () => {
             expect(hook.result.current.endDate).toBeNull();
         });
         it('should fallback to default values when URL params are cleared', async () => {
-            mockSearchParams.set('query', 'custom query');
-            mockSearchParams.set('sort', 'custom.sort asc');
-            mockSearchParams.set('span', 'date.range.1.week');
+            mockSearchParams = new URLSearchParams({
+                query: 'custom query',
+                sort: 'custom.sort asc',
+                span: 'date.range.1.week'
+            });
             mockLocation.search = mockSearchParams.toString();
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                 query: ctx.query,
@@ -633,9 +658,7 @@ describe('ParameterContext', () => {
             })), { wrapper: Wrapper });
             expect(hook.result.current.query).toBe('custom query');
             // Simulate clearing URL params
-            for (const key of [...mockSearchParams.keys()]) {
-                mockSearchParams.delete(key);
-            }
+            mockSearchParams = new URLSearchParams();
             mockLocation.search = '';
             hook.rerender();
             await waitFor(() => {
@@ -663,7 +686,6 @@ describe('ParameterContext', () => {
                 hook.result.current.setSpan('date.range.1.week');
                 hook.result.current.addFilter('status:resolved');
             });
-            hook.rerender();
             await waitFor(() => {
                 expect(hook.result.current.query).toBe('multi query');
                 expect(hook.result.current.sort).toBe('multi.sort desc');
@@ -684,308 +706,25 @@ describe('ParameterContext', () => {
             });
         });
     });
-    describe('indexes (multi-index support)', () => {
-        it('should initialize with default ["hit"] when no index params are present', async () => {
-            const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.indexes), { wrapper: Wrapper });
-            expect(hook.result.current).toEqual(['hit']);
-        });
-        it('should initialize with single index from URL', async () => {
-            mockSearchParams.set('index', 'observable');
-            const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.indexes), { wrapper: Wrapper });
-            expect(hook.result.current).toEqual(['observable']);
-        });
-        it('should initialize with multiple indexes from URL', async () => {
-            mockSearchParams.append('index', 'hit');
-            mockSearchParams.append('index', 'observable');
-            const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.indexes), { wrapper: Wrapper });
-            expect(hook.result.current).toEqual(['hit', 'observable']);
-        });
-        it('should deduplicate repeated index values from URL', async () => {
-            mockSearchParams.append('index', 'hit');
-            mockSearchParams.append('index', 'hit');
-            const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.indexes), { wrapper: Wrapper });
-            expect(hook.result.current).toEqual(['hit']);
-        });
-        describe('addIndex', () => {
-            it('should add an index to the default array', async () => {
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    indexes: ctx.indexes,
-                    addIndex: ctx.addIndex
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.addIndex('observable');
-                });
-                await waitFor(() => {
-                    expect(hook.result.current.indexes).toEqual(['hit', 'observable']);
-                });
-            });
-            it('should not add a duplicate index', async () => {
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    indexes: ctx.indexes,
-                    addIndex: ctx.addIndex
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.addIndex('hit');
-                });
-                await waitFor(() => {
-                    expect(hook.result.current.indexes).toEqual(['hit']);
-                });
-            });
-        });
-        describe('removeIndex', () => {
-            it('should remove an index from the list', async () => {
-                mockSearchParams.append('index', 'hit');
-                mockSearchParams.append('index', 'observable');
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    indexes: ctx.indexes,
-                    removeIndex: ctx.removeIndex
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.removeIndex('hit');
-                });
-                await waitFor(() => {
-                    expect(hook.result.current.indexes).toEqual(['observable']);
-                });
-            });
-            it('should do nothing when removing a nonexistent index', async () => {
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    indexes: ctx.indexes,
-                    removeIndex: ctx.removeIndex
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.removeIndex('observable');
-                });
-                await waitFor(() => {
-                    expect(hook.result.current.indexes).toEqual(['hit']);
-                });
-            });
-            it('should handle removing from empty array', async () => {
-                mockSearchParams.append('index', 'hit');
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    indexes: ctx.indexes,
-                    removeIndex: ctx.removeIndex
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.removeIndex('hit');
-                });
-                await waitFor(() => {
-                    expect(hook.result.current.indexes).toEqual([]);
-                });
-            });
-        });
-        describe('setIndex', () => {
-            it('should update the index at the specified position', async () => {
-                mockSearchParams.append('index', 'hit');
-                mockSearchParams.append('index', 'observable');
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    indexes: ctx.indexes,
-                    setIndex: ctx.setIndex
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.setIndex(0, 'observable');
-                });
-                await waitFor(() => {
-                    expect(hook.result.current.indexes).toEqual(['observable', 'observable']);
-                });
-            });
-            it('should do nothing when index is out of bounds', async () => {
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    indexes: ctx.indexes,
-                    setIndex: ctx.setIndex
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.setIndex(5, 'observable');
-                });
-                await waitFor(() => {
-                    expect(hook.result.current.indexes).toEqual(['hit']);
-                });
-            });
-            it('should do nothing when position is negative', async () => {
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    indexes: ctx.indexes,
-                    setIndex: ctx.setIndex
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.setIndex(-1, 'observable');
-                });
-                await waitFor(() => {
-                    expect(hook.result.current.indexes).toEqual(['hit']);
-                });
-            });
-        });
-        describe('setIndexes', () => {
-            it('should replace all indexes with the provided list', async () => {
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    indexes: ctx.indexes,
-                    setIndexes: ctx.setIndexes
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.setIndexes(['observable']);
-                });
-                await waitFor(() => {
-                    expect(hook.result.current.indexes).toEqual(['observable']);
-                });
-            });
-            it('should deduplicate values when setting all indexes', async () => {
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    indexes: ctx.indexes,
-                    setIndexes: ctx.setIndexes
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.setIndexes(['hit', 'hit', 'observable']);
-                });
-                await waitFor(() => {
-                    expect(hook.result.current.indexes).toEqual(['hit', 'observable']);
-                });
-            });
-            it('should set to empty array', async () => {
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    indexes: ctx.indexes,
-                    setIndexes: ctx.setIndexes
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.setIndexes([]);
-                });
-                await waitFor(() => {
-                    expect(hook.result.current.indexes).toEqual([]);
-                });
-            });
-        });
-        describe('resetIndexes', () => {
-            it('should reset indexes to default ["hit"]', async () => {
-                mockSearchParams.append('index', 'hit');
-                mockSearchParams.append('index', 'observable');
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    indexes: ctx.indexes,
-                    resetIndexes: ctx.resetIndexes
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.resetIndexes();
-                });
-                await waitFor(() => {
-                    expect(hook.result.current.indexes).toEqual(['hit']);
-                });
-            });
-            it('should reset to default even when called on empty array', async () => {
-                mockSearchParams.append('index', 'hit');
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    indexes: ctx.indexes,
-                    removeIndex: ctx.removeIndex,
-                    resetIndexes: ctx.resetIndexes
-                })), { wrapper: Wrapper });
-                // First empty it
-                await act(async () => {
-                    hook.result.current.removeIndex('hit');
-                });
-                await waitFor(() => {
-                    expect(hook.result.current.indexes).toEqual([]);
-                });
-                // Resetting always returns to default ['hit']
-                await act(async () => {
-                    hook.result.current.resetIndexes();
-                });
-                await waitFor(() => {
-                    expect(hook.result.current.indexes).toEqual(['hit']);
-                });
-            });
-        });
-        describe('URL synchronization', () => {
-            it('should not write the default ["hit"] index to the URL', async () => {
-                renderHook(() => useContextSelector(ParameterContext, ctx => ctx.indexes), { wrapper: Wrapper });
-                // Allow any effects to flush
-                await waitFor(() => {
-                    // If setParams was called, the URL must not contain ?index=hit
-                    if (mockSetParams.mock.calls.length > 0) {
-                        const call = mockSetParams.mock.calls[mockSetParams.mock.calls.length - 1];
-                        const urlParams = typeof call[0] === 'function' ? call[0](mockSearchParams) : call[0];
-                        expect(urlParams.getAll('index')).toEqual([]);
-                    }
-                    else {
-                        // setParams not called at all is also fine
-                        expect(true).toBe(true);
-                    }
-                });
-            });
-            it('should write a non-default index to the URL', async () => {
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    addIndex: ctx.addIndex,
-                    resetIndexes: ctx.resetIndexes
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.resetIndexes();
-                    hook.result.current.addIndex('observable');
-                });
-                await waitFor(() => {
-                    expect(mockSetParams).toHaveBeenCalled();
-                    const call = mockSetParams.mock.calls[mockSetParams.mock.calls.length - 1];
-                    const urlParams = typeof call[0] === 'function' ? call[0](mockSearchParams) : call[0];
-                    expect(urlParams.getAll('index')).toEqual(['hit', 'observable']);
-                });
-            });
-            it('should sync multiple indexes to URL as multiple index params', async () => {
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    addIndex: ctx.addIndex
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.addIndex('observable');
-                });
-                await waitFor(() => {
-                    expect(mockSetParams).toHaveBeenCalled();
-                    const call = mockSetParams.mock.calls[mockSetParams.mock.calls.length - 1];
-                    const urlParams = typeof call[0] === 'function' ? call[0](mockSearchParams) : call[0];
-                    expect(urlParams.getAll('index')).toEqual(['hit', 'observable']);
-                });
-            });
-            it('should remove all index params from URL when state resets to default', async () => {
-                mockSearchParams.append('index', 'hit');
-                mockSearchParams.append('index', 'observable');
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    resetIndexes: ctx.resetIndexes
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.resetIndexes();
-                });
-                await waitFor(() => {
-                    expect(mockSetParams).toHaveBeenCalled();
-                    const call = mockSetParams.mock.calls[mockSetParams.mock.calls.length - 1];
-                    const urlParams = typeof call[0] === 'function' ? call[0](mockSearchParams) : call[0];
-                    expect(urlParams.getAll('index')).toEqual([]);
-                });
-            });
-            it('should remove index param from URL when state returns to default', async () => {
-                mockSearchParams.set('index', 'observable');
-                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    setIndexes: ctx.setIndexes
-                })), { wrapper: Wrapper });
-                await act(async () => {
-                    hook.result.current.setIndexes(['hit']);
-                });
-                await waitFor(() => {
-                    expect(mockSetParams).toHaveBeenCalled();
-                    const call = mockSetParams.mock.calls[mockSetParams.mock.calls.length - 1];
-                    const urlParams = typeof call[0] === 'function' ? call[0](mockSearchParams) : call[0];
-                    expect(urlParams.getAll('index')).toEqual([]);
-                });
-            });
-        });
-    });
     describe('views (multi-view support)', () => {
         it('should initialize with empty array when no view params present', async () => {
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.views), { wrapper: Wrapper });
             expect(hook.result.current).toEqual([]);
         });
         it('should initialize with single view from URL', async () => {
-            mockSearchParams.set('view', 'view_1');
+            mockSearchParams = new URLSearchParams({ view: 'view_1' });
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.views), { wrapper: Wrapper });
             expect(hook.result.current).toEqual(['view_1']);
         });
         it('should initialize with multiple views from URL', async () => {
+            mockSearchParams = new URLSearchParams();
             mockSearchParams.append('view', 'view_1');
             mockSearchParams.append('view', 'view_2');
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.views), { wrapper: Wrapper });
             expect(hook.result.current).toEqual(['view_1', 'view_2']);
         });
         it('should preserve view order from URL', async () => {
+            mockSearchParams = new URLSearchParams();
             mockSearchParams.append('view', 'view_c');
             mockSearchParams.append('view', 'view_a');
             mockSearchParams.append('view', 'view_b');
@@ -993,6 +732,7 @@ describe('ParameterContext', () => {
             expect(hook.result.current).toEqual(['view_c', 'view_a', 'view_b']);
         });
         it('should deduplicate multiple empty view params to single empty string', async () => {
+            mockSearchParams = new URLSearchParams();
             mockSearchParams.append('view', '');
             mockSearchParams.append('view', '');
             mockSearchParams.append('view', '');
@@ -1013,7 +753,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should append view to existing views', async () => {
-                mockSearchParams.set('view', 'existing_view');
+                mockSearchParams = new URLSearchParams({ view: 'existing_view' });
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     views: ctx.views,
                     addView: ctx.addView
@@ -1026,7 +766,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should not add duplicate views', async () => {
-                mockSearchParams.set('view', 'view_1');
+                mockSearchParams = new URLSearchParams({ view: 'view_1' });
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     views: ctx.views,
                     addView: ctx.addView
@@ -1042,6 +782,7 @@ describe('ParameterContext', () => {
         });
         describe('removeView', () => {
             it('should remove first matching view', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('view', 'view_1');
                 mockSearchParams.append('view', 'view_2');
                 mockSearchParams.append('view', 'view_3');
@@ -1057,6 +798,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should remove only first occurrence of duplicate views', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('view', 'dup');
                 mockSearchParams.append('view', 'dup');
                 mockSearchParams.append('view', 'other');
@@ -1072,7 +814,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should do nothing when removing nonexistent view', async () => {
-                mockSearchParams.set('view', 'existing');
+                mockSearchParams = new URLSearchParams({ view: 'existing' });
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     views: ctx.views,
                     removeView: ctx.removeView
@@ -1097,16 +839,17 @@ describe('ParameterContext', () => {
                 });
             });
         });
-        describe('resetViews', () => {
+        describe('clearViews', () => {
             it('should clear all views', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('view', 'view_1');
                 mockSearchParams.append('view', 'view_2');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     views: ctx.views,
-                    resetViews: ctx.resetViews
+                    clearViews: ctx.clearViews
                 })), { wrapper: Wrapper });
                 await act(async () => {
-                    hook.result.current.resetViews();
+                    hook.result.current.clearViews();
                 });
                 await waitFor(() => {
                     expect(hook.result.current.views).toEqual([]);
@@ -1115,10 +858,10 @@ describe('ParameterContext', () => {
             it('should be no-op when already empty', async () => {
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     views: ctx.views,
-                    resetViews: ctx.resetViews
+                    clearViews: ctx.clearViews
                 })), { wrapper: Wrapper });
                 await act(async () => {
-                    hook.result.current.resetViews();
+                    hook.result.current.clearViews();
                 });
                 await waitFor(() => {
                     expect(hook.result.current.views).toEqual([]);
@@ -1127,6 +870,7 @@ describe('ParameterContext', () => {
         });
         describe('setView', () => {
             it('should update view at specified index', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('view', 'view_1');
                 mockSearchParams.append('view', 'view_2');
                 mockSearchParams.append('view', 'view_3');
@@ -1142,6 +886,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should update view at index 0', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('view', 'old_view');
                 mockSearchParams.append('view', 'view_2');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
@@ -1156,6 +901,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should update view at last index', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('view', 'view_1');
                 mockSearchParams.append('view', 'old_last');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
@@ -1170,7 +916,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should do nothing when index is out of bounds', async () => {
-                mockSearchParams.set('view', 'existing');
+                mockSearchParams = new URLSearchParams({ view: 'existing' });
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     views: ctx.views,
                     setView: ctx.setView
@@ -1183,7 +929,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should do nothing when index is negative', async () => {
-                mockSearchParams.set('view', 'existing');
+                mockSearchParams = new URLSearchParams({ view: 'existing' });
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     views: ctx.views,
                     setView: ctx.setView
@@ -1208,6 +954,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should sync updated view to URL', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('view', 'view_1');
                 mockSearchParams.append('view', 'view_2');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
@@ -1257,13 +1004,14 @@ describe('ParameterContext', () => {
                 });
             });
             it('should remove all view params when views is empty', async () => {
+                mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('view', 'view_1');
                 mockSearchParams.append('view', 'view_2');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
-                    resetViews: ctx.resetViews
+                    clearViews: ctx.clearViews
                 })), { wrapper: Wrapper });
                 await act(async () => {
-                    hook.result.current.resetViews();
+                    hook.result.current.clearViews();
                 });
                 await waitFor(() => {
                     expect(mockSetParams).toHaveBeenCalled();