@cccsaurora/howler-ui 2.19.0-dev.1151 → 2.19.0-dev.1260

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

@@ -0,0 +1,23 @@
+import type { Event } from '@cccsaurora/howler-ui/models/entities/generated/Event';
+import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import type { WithMetadata } from '@cccsaurora/howler-ui/models/WithMetadata';
+import type { FC, PropsWithChildren } from 'react';
+export interface RecordContextType {
+    records: {
+        [index: string]: Hit | Event;
+    };
+    selectedRecords: (Hit | Event)[];
+    addRecordToSelection: (id: string) => void;
+    removeRecordFromSelection: (id: string) => void;
+    clearSelectedRecords: (except?: string) => void;
+    loadRecords: (hits: (Hit | Event)[]) => void;
+    updateRecord: (newHit: Hit | Event) => void;
+    getRecord: (id: string, force?: boolean) => Promise<WithMetadata<Hit | Event>>;
+}
+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 useRecordContextSelector: <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,72 @@ 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.v2.search.post(['hit', 'event'], {
+                query: `howler.id:${id}`,
+                rows: 1,
+                metadata: ['template', 'dossiers', 'analytic', 'overview']
+            })).then(result => result.items[0]);
+            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);
+export const useRecordContextSelector = (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 { Event } from '@cccsaurora/howler-ui/models/entities/generated/Event';
 import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
 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 | Event>> | 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;

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

@@ -4,23 +4,22 @@ import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
 import useMyLocalStorage, { useMyLocalStorageItem } from '@cccsaurora/howler-ui/components/hooks/useMyLocalStorage';
 import dayjs from 'dayjs';
 import i18n from '@cccsaurora/howler-ui/i18n';
-import { cloneDeep } from 'lodash-es';
+import { cloneDeep, isNil } from 'lodash-es';
 import isNull from 'lodash-es/isNull';
 import isUndefined from 'lodash-es/isUndefined';
 import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useLocation, useParams } from 'react-router-dom';
+import { useLocation } from 'react-router-dom';
 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 HitSearchContext = createContext(null);
+export const RecordSearchContext = createContext(null);
 const THROTTLER = new Throttler(500);
-const HitSearchProvider = ({ children }) => {
+const RecordSearchProvider = ({ children }) => {
     const { get } = useMyLocalStorage();
-    const routeParams = useParams();
     const location = useLocation();
     const { dispatchApi } = useMyApi();
     const pageCount = useMyLocalStorageItem(StorageKey.PAGE_COUNT, 25)[0];
@@ -33,12 +32,13 @@ const HitSearchProvider = ({ 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(HitContext, ctx => ctx.loadHits);
+    const loadHits = useContextSelector(RecordContext, ctx => ctx.loadRecords);
     const [displayType, setDisplayType] = useState(get(StorageKey.DISPLAY_TYPE) ?? 'list');
     const [searching, setSearching] = useState(false);
     const [error, setError] = useState(null);
@@ -47,7 +47,6 @@ const HitSearchProvider = ({ 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,11 +69,6 @@ const HitSearchProvider = ({ 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 });
@@ -85,7 +79,7 @@ const HitSearchProvider = ({ children }) => {
                 .forEach(viewQuery => _filters.push(viewQuery));
         }
         return _filters;
-    }, [endDate, filters, getCurrentViews, location.pathname, routeParams.id, span, startDate, views]);
+    }, [endDate, filters, getCurrentViews, span, startDate, views]);
     const search = useCallback(async (_query, appendResults) => {
         THROTTLER.debounce(async () => {
             if (_query === 'woof!') {
@@ -105,8 +99,8 @@ const HitSearchProvider = ({ children }) => {
             setSearching(true);
             setError(null);
             try {
-                const _response = await dispatchApi(api.search.hit.post({
-                    offset: appendResults && response ? response.rows : offset,
+                const _response = await dispatchApi(api.v2.search.post(indexes, {
+                    offset: appendResults && !isNil(response?.rows) ? response.rows : offset,
                     rows: pageCount,
                     query: _query || DEFAULT_QUERY,
                     sort,
@@ -139,43 +133,37 @@ const HitSearchProvider = ({ children }) => {
                 setSearching(false);
             }
         });
-    }, 
-    // We skip reloading when the response changes
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [
+    }, [
         sort,
         span,
         query,
-        startDate,
-        endDate,
-        filters,
+        indexes,
         setQuery,
-        location.pathname,
-        routeParams.id,
-        views,
-        dispatchApi,
+        setQueryHistory,
+        queryHistory,
+        response?.rows,
         offset,
+        dispatchApi,
         pageCount,
+        getFilters,
         trackTotalHits,
         loadHits,
-        getCurrentViews,
-        setOffset,
-        getFilters
+        setOffset
     ]);
     // We only run this when ancillary properties (i.e. filters, sorting) change
     useEffect(() => {
         if (span?.endsWith('custom') && (!startDate || !endDate)) {
             return;
         }
-        if (views.length > 0 || bundleId || (query && query !== DEFAULT_QUERY) || offset > 0 || filters.length > 0) {
+        if (views.length > 0 || (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, bundleId, location.pathname, startDate, endDate, filters, query, views]);
-    return (_jsx(HitSearchContext.Provider, { value: {
+    }, [offset, pageCount, sort, span, indexes, location.pathname, startDate, endDate, filters, query, views]);
+    return (_jsx(RecordSearchContext.Provider, { value: {
             displayType,
             setDisplayType,
             search,
@@ -183,11 +171,10 @@ const HitSearchProvider = ({ children }) => {
             getFilters,
             error,
             response,
-            bundleId,
             setQueryHistory,
             queryHistory,
             fzfSearch,
             setFzfSearch
         }, children: children }));
 };
-export default HitSearchProvider;
+export default RecordSearchProvider;