@cccsaurora/howler-ui 2.19.0-cases.862 → 2.19.0-dev.1000

package/components/app/providers/{RecordProvider.js → HitProvider.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 RecordContext = createContext(null);
+export const HitContext = createContext(null);
 /**
  * Central repository for storing individual hit data across the application. Allows efficient retrieval of hits across componenents.
  */
-const RecordProvider = ({ children }) => {
+const HitProvider = ({ 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 getRecord for this reason.
+     * when two cards request the same hit that's missing from the store. Used in getHit for this reason.
      */
-    const recordRequests = useRef({});
+    const hitRequests = 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 [records, setRecords] = useState({});
+    const [hits, setHits] = 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 RecordProvider = ({ children }) => {
         if (data.hit) {
             // eslint-disable-next-line no-console
             console.debug('Received websocket update for hit', data.hit.howler.id);
-            recordRequests.current[data.hit.howler.id] = Promise.resolve(data.hit);
-            setRecords(_hits => ({
+            hitRequests.current[data.hit.howler.id] = Promise.resolve(data.hit);
+            setHits(_hits => ({
                 ..._hits,
                 [data.hit.howler.id]: {
                     ..._hits[data.hit.howler.id],
@@ -46,68 +46,68 @@ const RecordProvider = ({ children }) => {
         return () => removeListener('hits');
     }, [addListener, handler, removeListener]);
     /**
-     * A method to retrieve a record from the context. It first checks the hit state,
+     * A method to retrieve a hit from the context. It first checks the hit state,
      * then checks for ongoing requests, then finally executes a new request if necessary.
      */
-    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 }));
+    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 }));
         }
-        return recordRequests.current[id];
+        return hitRequests.current[id];
     }, [dispatchApi]);
     /**
      * Update a hit in the context locally
      */
-    const updateRecord = useCallback((newHit) => {
-        recordRequests.current[newHit.howler.id] = Promise.resolve(newHit);
-        setRecords(_hits => ({ ..._hits, [newHit.howler.id]: newHit }));
+    const updateHit = useCallback((newHit) => {
+        hitRequests.current[newHit.howler.id] = Promise.resolve(newHit);
+        setHits(_hits => ({ ..._hits, [newHit.howler.id]: newHit }));
     }, []);
     /**
      * Add a large number of hits to the cache. Used for results of searches.
      */
-    const loadRecords = useCallback((newHits) => {
+    const loadHits = useCallback((newHits) => {
         const mappedHits = newHits.map(hit => [hit.howler.id, hit]);
         mappedHits.forEach(([id, hit]) => {
-            recordRequests.current[id] = Promise.resolve(hit);
+            hitRequests.current[id] = Promise.resolve(hit);
         });
-        setRecords(_hits => ({ ..._hits, ...Object.fromEntries(mappedHits) }));
+        setHits(_hits => ({ ..._hits, ...Object.fromEntries(mappedHits) }));
     }, []);
-    const addRecordToSelection = useCallback((id) => {
+    const addHitToSelection = useCallback((id) => {
         setSelectedHitIds(_selected => uniq([..._selected, id]));
     }, []);
-    const removeRecordFromSelection = useCallback((id) => {
+    const removeHitFromSelection = useCallback((id) => {
         setSelectedHitIds(_selected => _selected.filter(_id => _id !== id));
     }, []);
-    const clearSelectedRecords = useCallback((except) => {
+    const clearSelectedHits = useCallback((except) => {
         setSelectedHitIds(!!except ? [except] : []);
     }, []);
-    const selectedRecords = useMemo(() => selectedHitIds.map(id => records[id]).filter(hit => !!hit), [records, selectedHitIds]);
+    const selectedHits = useMemo(() => selectedHitIds.map(id => hits[id]).filter(hit => !!hit), [hits, selectedHitIds]);
     useEffect(() => {
         selectedHitIds.forEach(id => {
-            if (!recordRequests.current[id]) {
-                getRecord(id);
+            if (!hitRequests.current[id]) {
+                getHit(id);
             }
         });
-    }, [getRecord, selectedHitIds]);
+    }, [getHit, selectedHitIds]);
     useEffect(() => {
-        Object.entries(records).forEach(([id, hit]) => {
-            recordRequests.current[id] = Promise.resolve(hit);
+        Object.entries(hits).forEach(([id, hit]) => {
+            hitRequests.current[id] = Promise.resolve(hit);
         });
-    }, [records]);
-    return (_jsx(RecordContext.Provider, { value: {
-            records,
-            getRecord,
-            updateRecord,
-            selectedRecords,
-            addRecordToSelection,
-            removeRecordFromSelection,
-            clearSelectedRecords,
-            loadRecords
+    }, [hits]);
+    return (_jsx(HitContext.Provider, { value: {
+            hits,
+            getHit,
+            updateHit,
+            selectedHits,
+            addHitToSelection,
+            removeHitFromSelection,
+            clearSelectedHits,
+            loadHits
         }, children: children }));
 };
-export const useRecordContextSelector = (selector) => {
-    return useContextSelector(RecordContext, selector);
+export const useHitContextSelector = (selector) => {
+    return useContextSelector(HitContext, selector);
 };
-export default RecordProvider;
+export default HitProvider;

package/components/app/providers/{RecordSearchProvider.d.ts → HitSearchProvider.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 RecordSearchContextType {
+export interface HitSearchContextType {
     displayType: 'list' | 'grid';
     searching: boolean;
     error: string | null;
-    response: HowlerSearchResponse<WithMetadata<Hit | Observable>> | null;
+    response: HowlerSearchResponse<WithMetadata<Hit>> | null;
+    bundleId: string | null;
     fzfSearch: boolean;
     setDisplayType: (type: 'list' | 'grid') => void;
     setFzfSearch: Dispatch<SetStateAction<boolean>>;
@@ -20,6 +20,6 @@ export interface RecordSearchContextType {
     queryHistory: QueryEntry;
     setQueryHistory: ReturnType<typeof useMyLocalStorageItem>[1];
 }
-export declare const RecordSearchContext: import("use-context-selector").Context<RecordSearchContextType>;
-declare const RecordSearchProvider: FC<PropsWithChildren>;
-export default RecordSearchProvider;
+export declare const HitSearchContext: import("use-context-selector").Context<HitSearchContextType>;
+declare const HitSearchProvider: FC<PropsWithChildren>;
+export default HitSearchProvider;

package/components/app/providers/{RecordSearchProvider.js → HitSearchProvider.js}

@@ -13,12 +13,12 @@ import { createContext, useContextSelector } from 'use-context-selector';
 import { DEFAULT_QUERY, StorageKey } from '@cccsaurora/howler-ui/utils/constants';
 import Throttler from '@cccsaurora/howler-ui/utils/Throttler';
 import { convertCustomDateRangeToLucene, convertDateToLucene } from '@cccsaurora/howler-ui/utils/utils';
+import { HitContext } from './HitProvider';
 import { ParameterContext } from './ParameterProvider';
-import { RecordContext } from './RecordProvider';
 import { ViewContext } from './ViewProvider';
-export const RecordSearchContext = createContext(null);
+export const HitSearchContext = createContext(null);
 const THROTTLER = new Throttler(500);
-const RecordSearchProvider = ({ children }) => {
+const HitSearchProvider = ({ children }) => {
     const { get } = useMyLocalStorage();
     const routeParams = useParams();
     const location = useLocation();
@@ -33,13 +33,12 @@ const RecordSearchProvider = ({ children }) => {
     const trackTotalHits = useContextSelector(ParameterContext, ctx => ctx.trackTotalHits);
     const sort = useContextSelector(ParameterContext, ctx => ctx.sort);
     const span = useContextSelector(ParameterContext, ctx => ctx.span);
-    const indexes = useContextSelector(ParameterContext, ctx => ctx.indexes);
     const allFilters = useContextSelector(ParameterContext, ctx => ctx.filters);
     const startDate = useContextSelector(ParameterContext, ctx => ctx.startDate);
     const endDate = useContextSelector(ParameterContext, ctx => ctx.endDate);
     const views = useContextSelector(ParameterContext, ctx => ctx.views);
     const addView = useContextSelector(ParameterContext, ctx => ctx.addView);
-    const loadHits = useContextSelector(RecordContext, ctx => ctx.loadRecords);
+    const loadHits = useContextSelector(HitContext, ctx => ctx.loadHits);
     const [displayType, setDisplayType] = useState(get(StorageKey.DISPLAY_TYPE) ?? 'list');
     const [searching, setSearching] = useState(false);
     const [error, setError] = useState(null);
@@ -48,6 +47,7 @@ const RecordSearchProvider = ({ children }) => {
         'howler.id: *': new Date().toISOString()
     });
     const [fzfSearch, setFzfSearch] = useState(false);
+    const bundleId = useMemo(() => (location.pathname.startsWith('/bundles') ? routeParams.id : null), [location.pathname, routeParams.id]);
     const filters = useMemo(() => allFilters.filter(filter => !filter.endsWith('*')), [allFilters]);
     // On load check to filter out any queries older than one month
     useEffect(() => {
@@ -70,6 +70,11 @@ const RecordSearchProvider = ({ children }) => {
         else if (startDate && endDate) {
             _filters.push(`event.created:${convertCustomDateRangeToLucene(startDate, endDate)}`);
         }
+        // Add bundle filter
+        const bundle = location.pathname.startsWith('/bundles') && routeParams.id;
+        if (bundle) {
+            _filters.push(`howler.bundles:${bundle}`);
+        }
         // Fetch all view queries
         if (views.length > 0) {
             const viewObjects = await getCurrentViews({ views });
@@ -80,7 +85,7 @@ const RecordSearchProvider = ({ children }) => {
                 .forEach(viewQuery => _filters.push(viewQuery));
         }
         return _filters;
-    }, [endDate, filters, getCurrentViews, span, startDate, views]);
+    }, [endDate, filters, getCurrentViews, location.pathname, routeParams.id, span, startDate, views]);
     const search = useCallback(async (_query, appendResults) => {
         THROTTLER.debounce(async () => {
             if (_query === 'woof!') {
@@ -100,7 +105,7 @@ const RecordSearchProvider = ({ children }) => {
             setSearching(true);
             setError(null);
             try {
-                const _response = await dispatchApi(api.v2.search.post(indexes, {
+                const _response = await dispatchApi(api.search.hit.post({
                     offset: appendResults && response ? response.rows : offset,
                     rows: pageCount,
                     query: _query || DEFAULT_QUERY,
@@ -144,7 +149,6 @@ const RecordSearchProvider = ({ children }) => {
         startDate,
         endDate,
         filters,
-        indexes,
         setQuery,
         location.pathname,
         routeParams.id,
@@ -163,15 +167,15 @@ const RecordSearchProvider = ({ children }) => {
         if (span?.endsWith('custom') && (!startDate || !endDate)) {
             return;
         }
-        if (views.length > 0 || (query && query !== DEFAULT_QUERY) || offset > 0 || filters.length > 0) {
+        if (views.length > 0 || bundleId || (query && query !== DEFAULT_QUERY) || offset > 0 || filters.length > 0) {
             search(query);
         }
         else {
             setResponse(null);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [offset, pageCount, sort, span, indexes, location.pathname, startDate, endDate, filters, query, views]);
-    return (_jsx(RecordSearchContext.Provider, { value: {
+    }, [offset, pageCount, sort, span, bundleId, location.pathname, startDate, endDate, filters, query, views]);
+    return (_jsx(HitSearchContext.Provider, { value: {
             displayType,
             setDisplayType,
             search,
@@ -179,10 +183,11 @@ const RecordSearchProvider = ({ children }) => {
             getFilters,
             error,
             response,
+            bundleId,
             setQueryHistory,
             queryHistory,
             fzfSearch,
             setFzfSearch
         }, children: children }));
 };
-export default RecordSearchProvider;
+export default HitSearchProvider;