@cccsaurora/howler-ui 2.18.0-dev.676 → 2.18.0-dev.682

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

@@ -272,17 +272,17 @@ 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 +291,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([]);
@@ -441,10 +441,10 @@ describe('ParameterContext', () => {
                 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();
@@ -706,6 +706,299 @@ 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 = new URLSearchParams({ 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 = new URLSearchParams();
+            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 = new URLSearchParams();
+            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 = new URLSearchParams();
+                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 = new URLSearchParams();
+                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 = new URLSearchParams();
+                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 = new URLSearchParams();
+                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 = new URLSearchParams();
+                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 = new URLSearchParams();
+                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 = new URLSearchParams({ 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 });
@@ -839,17 +1132,17 @@ 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 +1151,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([]);
@@ -1008,10 +1301,10 @@ describe('ParameterContext', () => {
                 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();

package/components/app/providers/RecordProvider.d.ts

@@ -0,0 +1,23 @@
+import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import type { Observable } from '@cccsaurora/howler-ui/models/entities/generated/Observable';
+import type { WithMetadata } from '@cccsaurora/howler-ui/models/WithMetadata';
+import type { FC, PropsWithChildren } from 'react';
+export interface RecordContextType {
+    records: {
+        [index: string]: Hit | Observable;
+    };
+    selectedRecords: (Hit | Observable)[];
+    addRecordToSelection: (id: string) => void;
+    removeRecordFromSelection: (id: string) => void;
+    clearSelectedRecords: (except?: string) => void;
+    loadRecords: (hits: (Hit | Observable)[]) => void;
+    updateRecord: (newHit: Hit | Observable) => void;
+    getRecord: (id: string, force?: boolean) => Promise<WithMetadata<Hit | Observable>>;
+}
+export declare const RecordContext: import("use-context-selector").Context<RecordContextType>;
+/**
+ * Central repository for storing individual hit data across the application. Allows efficient retrieval of hits across componenents.
+ */
+declare const RecordProvider: FC<PropsWithChildren>;
+export declare const useHitContextSelector: <Selected>(selector: (value: RecordContextType) => Selected) => Selected;
+export default RecordProvider;

package/components/app/providers/{HitProvider.js → RecordProvider.js}

@@ -5,25 +5,25 @@ import { uniq } from 'lodash-es';
 import { useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
 import { createContext, useContextSelector } from 'use-context-selector';
 import { SocketContext } from './SocketProvider';
-export const HitContext = createContext(null);
+export const RecordContext = createContext(null);
 /**
  * Central repository for storing individual hit data across the application. Allows efficient retrieval of hits across componenents.
  */
-const HitProvider = ({ children }) => {
+const RecordProvider = ({ children }) => {
     const { dispatchApi } = useMyApi();
     const { addListener, removeListener } = useContext(SocketContext);
     /**
      * The most immediate of two levels of caching, this ref stores the raw promises for each hit.
      * Rapidly updates, good for uses in-context where parallel updates my be occurring, i.e.
-     * when two cards request the same hit that's missing from the store. Used in getHit for this reason.
+     * when two cards request the same hit that's missing from the store. Used in getRecord for this reason.
      */
-    const hitRequests = useRef({});
+    const recordRequests = useRef({});
     /**
      * The "Authoritative" store of hits. Changes here will trigger rerenders, and essentially
      * caches the result of the above promises. Slower to update, so used outside of the hitcontext
      * where parallel requests aren't an issue.
      */
-    const [hits, setHits] = useState({});
+    const [records, setRecords] = useState({});
     const [selectedHitIds, setSelectedHitIds] = useState([]);
     // The central location where we propagate any changes from hits made via websockets into the repository. We just save every update,
     // instead of caching it across many components inconsistently as before.
@@ -31,8 +31,8 @@ const HitProvider = ({ children }) => {
         if (data.hit) {
             // eslint-disable-next-line no-console
             console.debug('Received websocket update for hit', data.hit.howler.id);
-            hitRequests.current[data.hit.howler.id] = Promise.resolve(data.hit);
-            setHits(_hits => ({
+            recordRequests.current[data.hit.howler.id] = Promise.resolve(data.hit);
+            setRecords(_hits => ({
                 ..._hits,
                 [data.hit.howler.id]: {
                     ..._hits[data.hit.howler.id],
@@ -46,68 +46,68 @@ const HitProvider = ({ children }) => {
         return () => removeListener('hits');
     }, [addListener, handler, removeListener]);
     /**
-     * A method to retrieve a hit from the context. It first checks the hit state,
+     * A method to retrieve a record from the context. It first checks the hit state,
      * then checks for ongoing requests, then finally executes a new request if necessary.
      */
-    const getHit = useCallback(async (id, force = false) => {
-        if (!hitRequests.current[id] || force) {
-            hitRequests.current[id] = dispatchApi(api.hit.get(id, ['template', 'dossiers', 'analytic', 'overview']));
-            const newHit = await hitRequests.current[id];
-            setHits(_hits => ({ ..._hits, [id]: newHit }));
+    const getRecord = useCallback(async (id, force = false) => {
+        if (!recordRequests.current[id] || force) {
+            recordRequests.current[id] = dispatchApi(api.hit.get(id, ['template', 'dossiers', 'analytic', 'overview']));
+            const newRecord = await recordRequests.current[id];
+            setRecords(_records => ({ ..._records, [id]: newRecord }));
         }
-        return hitRequests.current[id];
+        return recordRequests.current[id];
     }, [dispatchApi]);
     /**
      * Update a hit in the context locally
      */
-    const updateHit = useCallback((newHit) => {
-        hitRequests.current[newHit.howler.id] = Promise.resolve(newHit);
-        setHits(_hits => ({ ..._hits, [newHit.howler.id]: newHit }));
+    const updateRecord = useCallback((newHit) => {
+        recordRequests.current[newHit.howler.id] = Promise.resolve(newHit);
+        setRecords(_hits => ({ ..._hits, [newHit.howler.id]: newHit }));
     }, []);
     /**
      * Add a large number of hits to the cache. Used for results of searches.
      */
-    const loadHits = useCallback((newHits) => {
+    const loadRecords = useCallback((newHits) => {
         const mappedHits = newHits.map(hit => [hit.howler.id, hit]);
         mappedHits.forEach(([id, hit]) => {
-            hitRequests.current[id] = Promise.resolve(hit);
+            recordRequests.current[id] = Promise.resolve(hit);
         });
-        setHits(_hits => ({ ..._hits, ...Object.fromEntries(mappedHits) }));
+        setRecords(_hits => ({ ..._hits, ...Object.fromEntries(mappedHits) }));
     }, []);
-    const addHitToSelection = useCallback((id) => {
+    const addRecordToSelection = useCallback((id) => {
         setSelectedHitIds(_selected => uniq([..._selected, id]));
     }, []);
-    const removeHitFromSelection = useCallback((id) => {
+    const removeRecordFromSelection = useCallback((id) => {
         setSelectedHitIds(_selected => _selected.filter(_id => _id !== id));
     }, []);
-    const clearSelectedHits = useCallback((except) => {
+    const clearSelectedRecords = useCallback((except) => {
         setSelectedHitIds(!!except ? [except] : []);
     }, []);
-    const selectedHits = useMemo(() => selectedHitIds.map(id => hits[id]).filter(hit => !!hit), [hits, selectedHitIds]);
+    const selectedRecords = useMemo(() => selectedHitIds.map(id => records[id]).filter(hit => !!hit), [records, selectedHitIds]);
     useEffect(() => {
         selectedHitIds.forEach(id => {
-            if (!hitRequests.current[id]) {
-                getHit(id);
+            if (!recordRequests.current[id]) {
+                getRecord(id);
             }
         });
-    }, [getHit, selectedHitIds]);
+    }, [getRecord, selectedHitIds]);
     useEffect(() => {
-        Object.entries(hits).forEach(([id, hit]) => {
-            hitRequests.current[id] = Promise.resolve(hit);
+        Object.entries(records).forEach(([id, hit]) => {
+            recordRequests.current[id] = Promise.resolve(hit);
         });
-    }, [hits]);
-    return (_jsx(HitContext.Provider, { value: {
-            hits,
-            getHit,
-            updateHit,
-            selectedHits,
-            addHitToSelection,
-            removeHitFromSelection,
-            clearSelectedHits,
-            loadHits
+    }, [records]);
+    return (_jsx(RecordContext.Provider, { value: {
+            records,
+            getRecord,
+            updateRecord,
+            selectedRecords,
+            addRecordToSelection,
+            removeRecordFromSelection,
+            clearSelectedRecords,
+            loadRecords
         }, children: children }));
 };
 export const useHitContextSelector = (selector) => {
-    return useContextSelector(HitContext, selector);
+    return useContextSelector(RecordContext, selector);
 };
-export default HitProvider;
+export default RecordProvider;

package/components/app/providers/{HitSearchProvider.d.ts → RecordSearchProvider.d.ts}

@@ -1,17 +1,17 @@
 import type { HowlerSearchResponse } from '@cccsaurora/howler-ui/api/search';
 import { useMyLocalStorageItem } from '@cccsaurora/howler-ui/components/hooks/useMyLocalStorage';
 import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import type { Observable } from '@cccsaurora/howler-ui/models/entities/generated/Observable';
 import type { WithMetadata } from '@cccsaurora/howler-ui/models/WithMetadata';
 import { type Dispatch, type FC, type PropsWithChildren, type SetStateAction } from 'react';
 export interface QueryEntry {
     [query: string]: string;
 }
-export interface HitSearchContextType {
+export interface RecordSearchContextType {
     displayType: 'list' | 'grid';
     searching: boolean;
     error: string | null;
-    response: HowlerSearchResponse<WithMetadata<Hit>> | null;
-    bundleId: string | null;
+    response: HowlerSearchResponse<WithMetadata<Hit | Observable>> | null;
     fzfSearch: boolean;
     setDisplayType: (type: 'list' | 'grid') => void;
     setFzfSearch: Dispatch<SetStateAction<boolean>>;
@@ -20,6 +20,6 @@ export interface HitSearchContextType {
     queryHistory: QueryEntry;
     setQueryHistory: ReturnType<typeof useMyLocalStorageItem>[1];
 }
-export declare const HitSearchContext: import("use-context-selector").Context<HitSearchContextType>;
-declare const HitSearchProvider: FC<PropsWithChildren>;
-export default HitSearchProvider;
+export declare const RecordSearchContext: import("use-context-selector").Context<RecordSearchContextType>;
+declare const RecordSearchProvider: FC<PropsWithChildren>;
+export default RecordSearchProvider;