@cccsaurora/howler-ui 2.19.0-dev.999 → 2.20.0-dev.1352

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

@@ -1,23 +1,18 @@
 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 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 { mockParams, mockLocation, mockSetParams, mockSearchParams } = setupReactRouterMock();
 const Wrapper = ({ children }) => {
     return _jsx(ParameterProvider, { children: children });
 };
 beforeEach(() => {
-    mockSearchParams = new URLSearchParams();
+    for (const key of [...mockSearchParams.keys()]) {
+        mockSearchParams.delete(key);
+    }
     mockSetParams.mockClear();
     mockLocation.pathname = '/hits';
     mockLocation.search = '';
@@ -39,15 +34,13 @@ describe('ParameterContext', () => {
         expect(hook.result.current.trackTotalHits).toBe(false);
     });
     it('should initialize with values from URL params', async () => {
-        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'
-        });
+        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');
         const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
             query: ctx.query,
             sort: ctx.sort,
@@ -66,11 +59,9 @@ describe('ParameterContext', () => {
         expect(hook.result.current.trackTotalHits).toBe(true);
     });
     it('should handle custom date span with start and end dates', async () => {
-        mockSearchParams = new URLSearchParams({
-            span: 'date.range.custom',
-            start_date: '2025-01-01',
-            end_date: '2025-12-31'
-        });
+        mockSearchParams.set('span', 'date.range.custom');
+        mockSearchParams.set('start_date', '2025-01-01');
+        mockSearchParams.set('end_date', '2025-12-31');
         const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
             span: ctx.span,
             startDate: ctx.startDate,
@@ -94,7 +85,7 @@ describe('ParameterContext', () => {
             });
         });
         it('should not update if the value is the same', async () => {
-            mockSearchParams = new URLSearchParams({ query: 'existing query' });
+            mockSearchParams.set('query', 'existing query');
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                 query: ctx.query,
                 setQuery: ctx.setQuery
@@ -134,11 +125,9 @@ describe('ParameterContext', () => {
             });
         });
         it('should clear startDate and endDate when span does not end with custom', async () => {
-            mockSearchParams = new URLSearchParams({
-                span: 'date.range.custom',
-                start_date: '2025-01-01',
-                end_date: '2025-12-31'
-            });
+            mockSearchParams.set('span', 'date.range.custom');
+            mockSearchParams.set('start_date', '2025-01-01');
+            mockSearchParams.set('end_date', '2025-12-31');
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                 span: ctx.span,
                 startDate: ctx.startDate,
@@ -161,19 +150,17 @@ describe('ParameterContext', () => {
             expect(hook.result.current).toEqual([]);
         });
         it('should initialize with single filter from URL', async () => {
-            mockSearchParams = new URLSearchParams({ filter: 'status:open' });
+            mockSearchParams.set('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');
@@ -181,7 +168,6 @@ 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', '');
@@ -202,7 +188,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should append filter to existing filters', async () => {
-                mockSearchParams = new URLSearchParams({ filter: 'existing:filter' });
+                mockSearchParams.set('filter', 'existing:filter');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     filters: ctx.filters,
                     addFilter: ctx.addFilter
@@ -215,7 +201,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should not add duplicate filters', async () => {
-                mockSearchParams = new URLSearchParams({ filter: 'status:open' });
+                mockSearchParams.set('filter', 'status:open');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     filters: ctx.filters,
                     addFilter: ctx.addFilter
@@ -231,7 +217,6 @@ 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');
@@ -247,7 +232,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should do nothing when removing nonexistent filter', async () => {
-                mockSearchParams = new URLSearchParams({ filter: 'existing' });
+                mockSearchParams.set('filter', 'existing');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     filters: ctx.filters,
                     removeFilter: ctx.removeFilter
@@ -272,17 +257,16 @@ describe('ParameterContext', () => {
                 });
             });
         });
-        describe('clearFilters', () => {
+        describe('resetFilters', () => {
             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,
-                    clearFilters: ctx.clearFilters
+                    resetFilters: ctx.resetFilters
                 })), { wrapper: Wrapper });
                 await act(async () => {
-                    hook.result.current.clearFilters();
+                    hook.result.current.resetFilters();
                 });
                 await waitFor(() => {
                     expect(hook.result.current.filters).toEqual([]);
@@ -291,10 +275,10 @@ describe('ParameterContext', () => {
             it('should be no-op when already empty', async () => {
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     filters: ctx.filters,
-                    clearFilters: ctx.clearFilters
+                    resetFilters: ctx.resetFilters
                 })), { wrapper: Wrapper });
                 await act(async () => {
-                    hook.result.current.clearFilters();
+                    hook.result.current.resetFilters();
                 });
                 await waitFor(() => {
                     expect(hook.result.current.filters).toEqual([]);
@@ -303,7 +287,6 @@ 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');
@@ -319,7 +302,6 @@ 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 => ({
@@ -334,7 +316,6 @@ 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 => ({
@@ -349,7 +330,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should do nothing when index is out of bounds', async () => {
-                mockSearchParams = new URLSearchParams({ filter: 'existing' });
+                mockSearchParams.set('filter', 'existing');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     filters: ctx.filters,
                     setFilter: ctx.setFilter
@@ -362,7 +343,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should do nothing when index is negative', async () => {
-                mockSearchParams = new URLSearchParams({ filter: 'existing' });
+                mockSearchParams.set('filter', 'existing');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     filters: ctx.filters,
                     setFilter: ctx.setFilter
@@ -387,7 +368,6 @@ 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 => ({
@@ -437,14 +417,13 @@ 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 => ({
-                    clearFilters: ctx.clearFilters
+                    resetFilters: ctx.resetFilters
                 })), { wrapper: Wrapper });
                 await act(async () => {
-                    hook.result.current.clearFilters();
+                    hook.result.current.resetFilters();
                 });
                 await waitFor(() => {
                     expect(mockSetParams).toHaveBeenCalled();
@@ -567,11 +546,11 @@ describe('ParameterContext', () => {
             });
         });
         it('should read changes from URL params', async () => {
-            mockSearchParams = new URLSearchParams({ query: 'initial query' });
+            mockSearchParams.set('query', 'initial query');
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.query), { wrapper: Wrapper });
             expect(hook.result.current).toBe('initial query');
             // Simulate URL change
-            mockSearchParams = new URLSearchParams({ query: 'updated query' });
+            mockSearchParams.set('query', 'updated query');
             mockLocation.search = '?query=updated%20query';
             hook.rerender();
             await waitFor(() => {
@@ -589,24 +568,34 @@ 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 = new URLSearchParams({ selected: 'bundle_123' });
+            mockSearchParams.set('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 = new URLSearchParams({ selected: 'different_hit_id' });
+            mockSearchParams.set('selected', 'different_hit_id');
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.selected), { wrapper: Wrapper });
             expect(hook.result.current).toBe('different_hit_id');
         });
+        it('should not sync query when default query differs from global default', async () => {
+            const CustomDefaultWrapper = ({ children }) => {
+                return _jsx(ParameterProvider, { defaults: { query: '' }, children: children });
+            };
+            const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.query), {
+                wrapper: CustomDefaultWrapper
+            });
+            expect(hook.result.current).toBe('');
+            await waitFor(() => {
+                expect(mockSetParams).not.toHaveBeenCalled();
+            });
+        });
     });
     describe('useParameterContextSelector', () => {
         it('should allow selecting specific values from context', async () => {
-            mockSearchParams = new URLSearchParams({
-                query: 'test query',
-                sort: 'test.field asc'
-            });
+            mockSearchParams.set('query', 'test query');
+            mockSearchParams.set('sort', 'test.field asc');
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                 query: ctx.query,
                 sort: ctx.sort
@@ -617,17 +606,17 @@ describe('ParameterContext', () => {
     });
     describe('edge cases', () => {
         it('should handle offset of 0 in URL params', async () => {
-            mockSearchParams = new URLSearchParams({ offset: '0' });
+            mockSearchParams.set('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 = new URLSearchParams({ track_total_hits: 'false' });
+            mockSearchParams.set('track_total_hits', 'false');
             let hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.trackTotalHits), {
                 wrapper: Wrapper
             });
             expect(hook.result.current).toBe(false);
-            mockSearchParams = new URLSearchParams({ track_total_hits: 'true' });
+            mockSearchParams.set('track_total_hits', 'true');
             hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.trackTotalHits), { wrapper: Wrapper });
             expect(hook.result.current).toBe(true);
         });
@@ -645,11 +634,9 @@ describe('ParameterContext', () => {
             expect(hook.result.current.endDate).toBeNull();
         });
         it('should fallback to default values when URL params are cleared', async () => {
-            mockSearchParams = new URLSearchParams({
-                query: 'custom query',
-                sort: 'custom.sort asc',
-                span: 'date.range.1.week'
-            });
+            mockSearchParams.set('query', 'custom query');
+            mockSearchParams.set('sort', 'custom.sort asc');
+            mockSearchParams.set('span', 'date.range.1.week');
             mockLocation.search = mockSearchParams.toString();
             const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                 query: ctx.query,
@@ -658,7 +645,9 @@ describe('ParameterContext', () => {
             })), { wrapper: Wrapper });
             expect(hook.result.current.query).toBe('custom query');
             // Simulate clearing URL params
-            mockSearchParams = new URLSearchParams();
+            for (const key of [...mockSearchParams.keys()]) {
+                mockSearchParams.delete(key);
+            }
             mockLocation.search = '';
             hook.rerender();
             await waitFor(() => {
@@ -686,6 +675,7 @@ 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');
@@ -706,25 +696,308 @@ 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', 'event');
+            const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.indexes), { wrapper: Wrapper });
+            expect(hook.result.current).toEqual(['event']);
+        });
+        it('should initialize with multiple indexes from URL', async () => {
+            mockSearchParams.append('index', 'hit');
+            mockSearchParams.append('index', 'event');
+            const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ctx.indexes), { wrapper: Wrapper });
+            expect(hook.result.current).toEqual(['hit', 'event']);
+        });
+        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('event');
+                });
+                await waitFor(() => {
+                    expect(hook.result.current.indexes).toEqual(['hit', 'event']);
+                });
+            });
+            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', 'event');
+                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(['event']);
+                });
+            });
+            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('event');
+                });
+                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', 'event');
+                const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
+                    indexes: ctx.indexes,
+                    setIndex: ctx.setIndex
+                })), { wrapper: Wrapper });
+                await act(async () => {
+                    hook.result.current.setIndex(0, 'event');
+                });
+                await waitFor(() => {
+                    expect(hook.result.current.indexes).toEqual(['event', 'event']);
+                });
+            });
+            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, 'event');
+                });
+                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, 'event');
+                });
+                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(['event']);
+                });
+                await waitFor(() => {
+                    expect(hook.result.current.indexes).toEqual(['event']);
+                });
+            });
+            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', 'event']);
+                });
+                await waitFor(() => {
+                    expect(hook.result.current.indexes).toEqual(['hit', 'event']);
+                });
+            });
+            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', 'event');
+                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('event');
+                });
+                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', 'event']);
+                });
+            });
+            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('event');
+                });
+                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', 'event']);
+                });
+            });
+            it('should remove all index params from URL when state resets to default', async () => {
+                mockSearchParams.append('index', 'hit');
+                mockSearchParams.append('index', 'event');
+                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', 'event');
+                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 = new URLSearchParams({ view: 'view_1' });
+            mockSearchParams.set('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');
@@ -732,7 +1005,6 @@ 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', '');
@@ -753,7 +1025,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should append view to existing views', async () => {
-                mockSearchParams = new URLSearchParams({ view: 'existing_view' });
+                mockSearchParams.set('view', 'existing_view');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     views: ctx.views,
                     addView: ctx.addView
@@ -766,7 +1038,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should not add duplicate views', async () => {
-                mockSearchParams = new URLSearchParams({ view: 'view_1' });
+                mockSearchParams.set('view', 'view_1');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     views: ctx.views,
                     addView: ctx.addView
@@ -782,7 +1054,6 @@ 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');
@@ -798,7 +1069,6 @@ 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');
@@ -814,7 +1084,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should do nothing when removing nonexistent view', async () => {
-                mockSearchParams = new URLSearchParams({ view: 'existing' });
+                mockSearchParams.set('view', 'existing');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     views: ctx.views,
                     removeView: ctx.removeView
@@ -839,17 +1109,16 @@ describe('ParameterContext', () => {
                 });
             });
         });
-        describe('clearViews', () => {
+        describe('resetViews', () => {
             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,
-                    clearViews: ctx.clearViews
+                    resetViews: ctx.resetViews
                 })), { wrapper: Wrapper });
                 await act(async () => {
-                    hook.result.current.clearViews();
+                    hook.result.current.resetViews();
                 });
                 await waitFor(() => {
                     expect(hook.result.current.views).toEqual([]);
@@ -858,10 +1127,10 @@ describe('ParameterContext', () => {
             it('should be no-op when already empty', async () => {
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     views: ctx.views,
-                    clearViews: ctx.clearViews
+                    resetViews: ctx.resetViews
                 })), { wrapper: Wrapper });
                 await act(async () => {
-                    hook.result.current.clearViews();
+                    hook.result.current.resetViews();
                 });
                 await waitFor(() => {
                     expect(hook.result.current.views).toEqual([]);
@@ -870,7 +1139,6 @@ 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');
@@ -886,7 +1154,6 @@ 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 => ({
@@ -901,7 +1168,6 @@ 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 => ({
@@ -916,7 +1182,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should do nothing when index is out of bounds', async () => {
-                mockSearchParams = new URLSearchParams({ view: 'existing' });
+                mockSearchParams.set('view', 'existing');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     views: ctx.views,
                     setView: ctx.setView
@@ -929,7 +1195,7 @@ describe('ParameterContext', () => {
                 });
             });
             it('should do nothing when index is negative', async () => {
-                mockSearchParams = new URLSearchParams({ view: 'existing' });
+                mockSearchParams.set('view', 'existing');
                 const hook = renderHook(() => useContextSelector(ParameterContext, ctx => ({
                     views: ctx.views,
                     setView: ctx.setView
@@ -954,7 +1220,6 @@ 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 => ({
@@ -1004,14 +1269,13 @@ 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 => ({
-                    clearViews: ctx.clearViews
+                    resetViews: ctx.resetViews
                 })), { wrapper: Wrapper });
                 await act(async () => {
-                    hook.result.current.clearViews();
+                    hook.result.current.resetViews();
                 });
                 await waitFor(() => {
                     expect(mockSetParams).toHaveBeenCalled();